Como personalizar anúncios de texto

A personalização de anúncios de texto padrão e expandidos pode ser feita por meio de personalizadores de anúncios, contagens regressivas e funções IF. Os personalizadores de anúncios oferecem maior flexibilidade do que usar parâmetros de anúncios.

Um personalizador de anúncios é uma solução com base em feeds que insere informações dinâmicas nos seus anúncios. Você pode configurar um feed com opções de segmentação para campanhas, grupos de anúncios e/ou palavras-chave específicos e, em seguida, criar anúncios que façam referência às informações no feed. Assim, os valores do feed são mostrados no momento da veiculação.

Você pode inserir strings, preços, números e até mesmo uma contagem regressiva até uma data ou hora específica no seu anúncio.

Personalizadores de anúncios

Um caso de uso comum de personalizadores de anúncios é a exibição de preço promocional em um item durante um determinado período. Para fazer isso, configure um feed com um atributo de string para o nome do item, outro atributo de string para o preço e um atributo de data para o dia em que sua promoção termina. Em seguida, preencha um item do feed da forma adequada.

Ao configurar seu anúncio, você faz referência ao item do feed, ao atributo do nome e ao do preço promocional do feed. O Google AdWords preencherá o anúncio automaticamente com o nome e o preço do item do feed.

Para usar a data de término do item do feed, inclua o atributo de data em uma função que instrui o Google AdWords a exibir uma contagem regressiva até a data de término do seu anúncio. Ao criar o anúncio, faça referência ao feed do item e aos atributos de nome, preço promocional e data de término do feed. O Google AdWords preencherá o anúncio automaticamente com o nome, o preço e a data de término do item do feed.

Na sua próxima promoção, você poderá reutilizar o anúncio atualizando os valores de preço do item do feed e a data de término em vez de criar um novo anúncio todas as vezes.

As seções a seguir descrevem todas as fases desse caso de uso, incluindo instruções de como:

  • configurar o feed e seus respectivos atributos;
  • criar itens de feed com os valores que você quer exibir nos seus anúncios;
  • segmentar itens de feed para uma campanha, grupo de anúncios ou palavra-chave específicos;
  • usar o feed em um anúncio;
  • adicionar uma contagem regressiva;
  • adicionar uma função IF.

Configurar o feed

A primeira etapa é criar um feed com todos os atributos necessários para você personalizar seu anúncio.

O feed abaixo tem três atributos, dois do tipo STRING e um do tipo DATE_TIME.

Java

AdCustomizerFeed customizerFeed = new AdCustomizerFeed();
customizerFeed.setFeedName(feedName);

AdCustomizerFeedAttribute nameAttribute = new AdCustomizerFeedAttribute();
nameAttribute.setName("Name");
nameAttribute.setType(AdCustomizerFeedAttributeType.STRING);

AdCustomizerFeedAttribute priceAttribute = new AdCustomizerFeedAttribute();
priceAttribute.setName("Price");
priceAttribute.setType(AdCustomizerFeedAttributeType.STRING);

AdCustomizerFeedAttribute dateAttribute = new AdCustomizerFeedAttribute();
dateAttribute.setName("Date");
dateAttribute.setType(AdCustomizerFeedAttributeType.DATE_TIME);

customizerFeed.setFeedAttributes(
    new AdCustomizerFeedAttribute[] {nameAttribute, priceAttribute, dateAttribute});

CSharp

AdCustomizerFeed feed = new AdCustomizerFeed() {
  feedName = feedName,
  feedAttributes = new AdCustomizerFeedAttribute[] {
    new AdCustomizerFeedAttribute() {
      name = "Name",
      type = AdCustomizerFeedAttributeType.STRING
    },
    new AdCustomizerFeedAttribute() {
      name = "Price",
      type = AdCustomizerFeedAttributeType.PRICE
    },
    new AdCustomizerFeedAttribute() {
      name = "Date",
      type = AdCustomizerFeedAttributeType.DATE_TIME
    },
  }
};

Python

customizer_feed = {
    'feedName': feed_name,
    'feedAttributes': [
        {'type': 'STRING', 'name': 'Name'},
        {'type': 'STRING', 'name': 'Price'},
        {'type': 'DATE_TIME', 'name': 'Date'}
    ]
}

PHP

$nameAttribute = new AdCustomizerFeedAttribute();
$nameAttribute->setName('Name');
$nameAttribute->setType(AdCustomizerFeedAttributeType::STRING);

$priceAttribute = new AdCustomizerFeedAttribute();
$priceAttribute->setName('Price');
$priceAttribute->setType(AdCustomizerFeedAttributeType::STRING);

$dateAttribute = new AdCustomizerFeedAttribute();
$dateAttribute->setName('Date');
$dateAttribute->setType(AdCustomizerFeedAttributeType::DATE_TIME);

$customizerFeed = new AdCustomizerFeed();
$customizerFeed->setFeedName($feedName);
$customizerFeed->setFeedAttributes(
    [$nameAttribute, $priceAttribute, $dateAttribute]
);

Perl

my $name_attribute =
  Google::Ads::AdWords::v201802::AdCustomizerFeedAttribute->new({
    type => "STRING",
    name => "Name"
  });
my $price_attribute =
  Google::Ads::AdWords::v201802::AdCustomizerFeedAttribute->new({
    type => "STRING",
    name => "Price"
  });
my $date_attribute =
  Google::Ads::AdWords::v201802::AdCustomizerFeedAttribute->new({
    type => "DATE_TIME",
    name => "Date"
  });
my $ad_customizer_feed = Google::Ads::AdWords::v201802::AdCustomizerFeed->new(
  {
    feedName       => $feed_name,
    feedAttributes => [$name_attribute, $price_attribute, $date_attribute]});

Ruby

feed = {
  :feed_name => feed_name,
  :feed_attributes => [
    {:name => 'Name', :type => 'STRING'},
    {:name => 'Price', :type => 'PRICE'},
    {:name => 'Date', :type => 'DATE_TIME'}
  ]
}

VB.NET

Using adCustomizerFeedService As AdCustomizerFeedService = DirectCast(user.GetService(
    AdWordsService.v201802.AdCustomizerFeedService), AdCustomizerFeedService)

  Dim feed As New AdCustomizerFeed()
  feed.feedName = feedName

  Dim attribute1 As New AdCustomizerFeedAttribute
  attribute1.name = "Name"
  attribute1.type = AdCustomizerFeedAttributeType.STRING

  Dim attribute2 As New AdCustomizerFeedAttribute
  attribute2.name = "Price"
  attribute2.type = AdCustomizerFeedAttributeType.PRICE

  Dim attribute3 As New AdCustomizerFeedAttribute
  attribute3.name = "Date"
  attribute3.type = AdCustomizerFeedAttributeType.DATE_TIME

  feed.feedAttributes = New AdCustomizerFeedAttribute() {
  attribute1, attribute2, attribute3
}

Anote os códigos do próprio feed e dos atributos. Eles serão necessários para a configuração do item do feed. Você pode buscar esses atributos diretamente no resultado da chamada mutate.

Java

AdCustomizerFeedOperation feedOperation = new AdCustomizerFeedOperation();
feedOperation.setOperand(customizerFeed);
feedOperation.setOperator(Operator.ADD);

AdCustomizerFeed addedFeed = adCustomizerFeedService.mutate(
    new AdCustomizerFeedOperation[] {feedOperation}).getValue()[0];

System.out.printf(
    "Created ad customizer feed with ID %d, name '%s' and attributes:%n",
    addedFeed.getFeedId(), addedFeed.getFeedName());
for (AdCustomizerFeedAttribute feedAttribute : addedFeed.getFeedAttributes()) {
  System.out.printf(
      "  ID: %d, name: '%s', type: %s%n",
      feedAttribute.getId(), feedAttribute.getName(), feedAttribute.getType());
}

CSharp

AdCustomizerFeedOperation feedOperation = new AdCustomizerFeedOperation();
feedOperation.operand = feed;
feedOperation.@operator = (Operator.ADD);

AdCustomizerFeed addedFeed = adCustomizerFeedService.mutate(
    new AdCustomizerFeedOperation[] { feedOperation }).value[0];

Console.WriteLine("Created ad customizer feed with ID = {0} and name = '{1}' and " +
    "attributes: ", addedFeed.feedId, addedFeed.feedName);

foreach (AdCustomizerFeedAttribute feedAttribute in addedFeed.feedAttributes) {
  Console.WriteLine("  ID: {0}, name: '{1}', type: {2}",
      feedAttribute.id, feedAttribute.name, feedAttribute.type);
}

Python

feed_service_operation = {
    'operator': 'ADD',
    'operand': customizer_feed
}

response = ad_customizer_feed_service.mutate([feed_service_operation])

if response and 'value' in response:
  feed = response['value'][0]
  feed_data = {
      'feedId': feed['feedId'],
      'nameId': feed['feedAttributes'][0]['id'],
      'priceId': feed['feedAttributes'][1]['id'],
      'dateId': feed['feedAttributes'][2]['id']
  }
  print ('Feed with name "%s" and ID %s was added with:\n'
         '\tName attribute ID %s and price attribute ID %s and date attribute'
         'ID %s') % (feed['feedName'], feed['feedId'], feed_data['nameId'],
                     feed_data['priceId'], feed_data['dateId'])

PHP

$feedOperation = new AdCustomizerFeedOperation();
$feedOperation->setOperand($customizerFeed);
$feedOperation->setOperator(Operator::ADD);
$operations = [$feedOperation];

$result = $adCustomizerFeedService->mutate($operations);
$addedFeed = $result->getValue()[0];

printf(
    "Created ad customizer feed with ID %d, name '%s' and attributes:\n",
    $addedFeed->getFeedId(),
    $addedFeed->getFeedName()
);
if (empty($addedFeed)) {
    print "  No attributes\n";
} else {
    foreach ($addedFeed->getFeedAttributes() as $feedAttribute) {
        printf(
            "  ID: %d, name: '%s', type: %s\n",
            $feedAttribute->getId(),
            $feedAttribute->getName(),
            $feedAttribute->getType()
        );
    }
}

Perl

my $operation = Google::Ads::AdWords::v201802::AdCustomizerFeedOperation->new(
  {
    operator => "ADD",
    operand  => $ad_customizer_feed
  });

my $feed_result =
  $client->AdCustomizerFeedService()->mutate({operations => [$operation]});

my $added_feed = $feed_result->get_value(0);

printf(
  "Created ad customizer feed with ID %d, and name '%s' and attributes:\n",
  $added_feed->get_feedId(),
  $added_feed->get_feedName());
foreach my $feed_attribute ($added_feed->get_feedAttributes()) {
  printf "  ID: %d, name: '%s', type: '%s'\n",
    $feed_attribute->get_id(), $feed_attribute->get_name(),
    $feed_attribute->get_type();
}

Ruby

operation = {:operand => feed, :operator => 'ADD'}
added_feed = ad_customizer_srv.mutate([operation])[:value].first()
puts "Created ad customizer feed with ID = %d and name = '%s'." %
    [added_feed[:feed_id], added_feed[:feed_name]]
added_feed[:feed_attributes].each do |feed_attribute|
  puts "  ID: %d, name: '%s', type: %s" %
      [feed_attribute[:id], feed_attribute[:name], feed_attribute[:type]]
end

VB.NET

Dim feedOperation As New AdCustomizerFeedOperation()
feedOperation.operand = feed
feedOperation.operator = [Operator].ADD

Dim addedFeed As AdCustomizerFeed = adCustomizerFeedService.mutate(
  New AdCustomizerFeedOperation() {feedOperation}).value(0)

Console.WriteLine("Created ad customizer feed with ID = {0} and name = '{1}'.",
                addedFeed.feedId, addedFeed.feedName)

Os atributos retornados aparecerão na mesma ordem especificada por você ao criar o feed.

Criar FeedItems segmentados

Crie um FeedItem para restringir o feed a apenas um grupo de anúncios, campanha, palavra-chave ou local específico usando os atributos campaignTargeting, adGroupTargeting, keywordTargeting ou geoTargeting do FeedItem.

Com os códigos recuperados ao criar o feed na etapa acima, você poderá adicionar itens do feed. O exemplo de código abaixo passa os valores de cada item de feed para uma função auxiliar.

Java

DateTime now = new DateTime();

DateTime marsDate = new DateTime(now.getYear(), now.getMonthOfYear(), 1, 0, 0);
feedItemOperations.add(createFeedItemAddOperation("Mars", "$1234.56",
    marsDate.toString("yyyyMMdd HHmmss"), adGroupIds.get(0), adCustomizerFeed));

DateTime venusDate = new DateTime(now.getYear(), now.getMonthOfYear(), 15, 0, 0);
feedItemOperations.add(createFeedItemAddOperation("Venus", "$1450.00",
    venusDate.toString("yyyyMMdd HHmmss"), adGroupIds.get(1), adCustomizerFeed));

CSharp

DateTime marsDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Mars", "$1234.56",
    marsDate.ToString("yyyyMMdd HHmmss"), adGroupIds[0]));

DateTime venusDate = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 15);
feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Venus", "$1450.00",
    venusDate.ToString("yyyyMMdd HHmmss"), adGroupIds[1]));

Python

now = datetime.now()
mars_date = datetime(now.year, now.month, 1, 0, 0)
venus_date = datetime(now.year, now.month, 15, 0, 0)
time_format = '%Y%m%d %H%M%S'

feed_item_operations = [
    CreateFeedItemAddOperation(
        'Mars', '$1234.56', mars_date.strftime(time_format), adgroup_ids[0],
        ad_customizer_feed),
    CreateFeedItemAddOperation(
        'Venus', '$1450.00', venus_date.strftime(time_format),
        adgroup_ids[1], ad_customizer_feed)
]

PHP

$marsDate = mktime(0, 0, 0, date('m'), 1, date('Y'));
$venusDate = mktime(0, 0, 0, date('m'), 15, date('Y'));

// Create multiple feed item operations and add them to the operations list.
$operations[] = self::createFeedItemAddOperation(
    'Mars',
    '$1234.56',
    date('Ymd His', $marsDate),
    $adGroupIds[0],
    $adCustomizerFeed
);
$operations[] = self::createFeedItemAddOperation(
    'Venus',
    '$1450.00',
    date('Ymd His', $venusDate),
    $adGroupIds[1],
    $adCustomizerFeed
);

Perl

push @operations,
  create_feed_item_add_operation($ad_customizer_feed,
  "Mars", "\$1234.56", "20140601 000000",
  $ad_group_ids->[0]);
push @operations,
  create_feed_item_add_operation($ad_customizer_feed,
  "Venus", "\$1450.00", "20140615 120000",
  $ad_group_ids->[1]);

Ruby

# Now adding feed items -- the values we'd like to place.
now_date = Date.today()

items_data = [
  {
    :name => 'Mars',
    :price => '$1234.56',
    :date => now_date.strftime('%Y%m01 000000'),
    :ad_group_id => ad_group_ids[0]
  },
  {
    :name => 'Venus',
    :price => '$1450.00',
    :date => now_date.strftime('%Y%m15 000000'),
    :ad_group_id => ad_group_ids[1]
   }
]

VB.NET

Dim marsDate As New DateTime(DateTime.Now.Year, DateTime.Now.Month, 1)
feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Mars", "$1234.56",
  marsDate.ToString("yyyyMMdd HHmmss"), adGroupIds(0)))

Dim venusDate As New DateTime(DateTime.Now.Year, DateTime.Now.Month, 15)
feedItemOperations.Add(CreateFeedItemAddOperation(adCustomizerFeed, "Venus", "$1450.00",
  venusDate.ToString("yyyyMMdd HHmmss"), adGroupIds(1)))

A função auxiliar configura o item de feed com os valores informados:

Java

FeedItem feedItem = new FeedItem();
feedItem.setFeedId(adCustomizerFeed.getFeedId());

List<FeedItemAttributeValue> attributeValues = new ArrayList<>();

// FeedAttributes appear in the same order as they were created - Name, Price, Date.
// See the createCustomizerFeed method for details.
FeedItemAttributeValue nameAttributeValue = new FeedItemAttributeValue();
nameAttributeValue.setFeedAttributeId(adCustomizerFeed.getFeedAttributes(0).getId());
nameAttributeValue.setStringValue(name);
attributeValues.add(nameAttributeValue);

FeedItemAttributeValue priceAttributeValue = new FeedItemAttributeValue();
priceAttributeValue.setFeedAttributeId(adCustomizerFeed.getFeedAttributes(1).getId());
priceAttributeValue.setStringValue(price);
attributeValues.add(priceAttributeValue);

FeedItemAttributeValue dateAttributeValue = new FeedItemAttributeValue();
dateAttributeValue.setFeedAttributeId(adCustomizerFeed.getFeedAttributes(2).getId());
dateAttributeValue.setStringValue(date);
attributeValues.add(dateAttributeValue);

feedItem.setAttributeValues(
    attributeValues.toArray(new FeedItemAttributeValue[attributeValues.size()]));

feedItem.setAdGroupTargeting(new FeedItemAdGroupTargeting(adGroupId));

CSharp

FeedItem feedItem = new FeedItem() {
  feedId = adCustomizerFeed.feedId,

  // FeedAttributes appear in the same order as they were created
  // - Name, Price, Date. See CreateCustomizerFeed method for details.
  attributeValues = new FeedItemAttributeValue[] {
    new FeedItemAttributeValue() {
      feedAttributeId = adCustomizerFeed.feedAttributes[0].id,
      stringValue = name
    },

    new FeedItemAttributeValue() {
      feedAttributeId = adCustomizerFeed.feedAttributes[1].id,
      stringValue = price
    },

    new FeedItemAttributeValue() {
      feedAttributeId = adCustomizerFeed.feedAttributes[2].id,
      stringValue = date
    }
  },

  adGroupTargeting = new FeedItemAdGroupTargeting() {
    TargetingAdGroupId = adGroupId
  }
};

Python

feed_item = {
    'feedId': ad_customizer_feed['feedId'],
    'adGroupTargeting': {
        'TargetingAdGroupId': adgroup_id
    },
    'attributeValues': [
        {
            'feedAttributeId': ad_customizer_feed['feedAttributes'][0]['id'],
            'stringValue': name
        },
        {
            'feedAttributeId': ad_customizer_feed['feedAttributes'][1]['id'],
            'stringValue': price
        },
        {
            'feedAttributeId': ad_customizer_feed['feedAttributes'][2]['id'],
            'stringValue': date
        }
    ]
}

operation = {
    'operator': 'ADD',
    'operand': feed_item
}

PHP

$nameAttributeValue = new FeedItemAttributeValue();
$nameAttributeValue->setFeedAttributeId(
    $adCustomizerFeed->getFeedAttributes()[0]->getId()
);
$nameAttributeValue->setStringValue($name);

$priceAttributeValue = new FeedItemAttributeValue();
$priceAttributeValue->setFeedAttributeId(
    $adCustomizerFeed->getFeedAttributes()[1]->getId()
);
$priceAttributeValue->setStringValue($price);

$dateAttributeValue = new FeedItemAttributeValue();
$dateAttributeValue->setFeedAttributeId(
    $adCustomizerFeed->getFeedAttributes()[2]->getId()
);
$dateAttributeValue->setStringValue($date);

$item = new FeedItem();
$item->setFeedId($adCustomizerFeed->getFeedId());
$item->setAttributeValues(
    [$nameAttributeValue, $priceAttributeValue, $dateAttributeValue]
);

$adGroupTargeting = new FeedItemAdGroupTargeting();
$adGroupTargeting->setTargetingAdGroupId($adGroupId);
$item->setAdGroupTargeting($adGroupTargeting);

Perl

my ($ad_customizer_feed, $name, $price, $date, $ad_group_id) = @_;

my $name_attribute_value =
  Google::Ads::AdWords::v201802::FeedItemAttributeValue->new({
    feedAttributeId =>
      $ad_customizer_feed->get_feedAttributes()->[0]->get_id(),
    stringValue => $name
  });
my $price_attribute_value =
  Google::Ads::AdWords::v201802::FeedItemAttributeValue->new({
    feedAttributeId =>
      $ad_customizer_feed->get_feedAttributes()->[1]->get_id(),
    stringValue => $price
  });
my $date_attribute_value =
  Google::Ads::AdWords::v201802::FeedItemAttributeValue->new({
    feedAttributeId =>
      $ad_customizer_feed->get_feedAttributes()->[2]->get_id(),
    stringValue => $date
  });

my $feed_item = Google::Ads::AdWords::v201802::FeedItem->new({
    feedId => $ad_customizer_feed->get_feedId(),
    attributeValues =>
      [$name_attribute_value, $price_attribute_value, $date_attribute_value],
    adGroupTargeting =>
      Google::Ads::AdWords::v201802::FeedItemAdGroupTargeting->new(
      {TargetingAdGroupId => $ad_group_id})});

Ruby

feed_items = items_data.map do |item|
  {
    :feed_id => feed_data[:feed_id],
    :attribute_values => [
      {
        :feed_attribute_id => feed_data[:name_id],
        :string_value => item[:name]
      },
      {
        :feed_attribute_id => feed_data[:price_id],
        :string_value => item[:price]
      },
      {
        :feed_attribute_id => feed_data[:date_id],
        :string_value => item[:date]
      }
    ],
    :ad_group_targeting => {
      :targeting_ad_group_id => item[:ad_group_id]
    }
  }
end

VB.NET

Dim feedItem As New FeedItem
feedItem.feedId = adCustomizerFeed.feedId
Dim attributeValues As New List(Of FeedItemAttributeValue)

' FeedAttributes appear in the same order as they were created
' - Name, Price, Date. See CreateCustomizerFeed method for details.
Dim nameAttributeValue As New FeedItemAttributeValue
nameAttributeValue.feedAttributeId = adCustomizerFeed.feedAttributes(0).id
nameAttributeValue.stringValue = nameValue
attributeValues.Add(nameAttributeValue)

Dim priceAttributeValue As New FeedItemAttributeValue
priceAttributeValue.feedAttributeId = adCustomizerFeed.feedAttributes(1).id
priceAttributeValue.stringValue = priceValue
attributeValues.Add(priceAttributeValue)

Dim dateAttributeValue As New FeedItemAttributeValue
dateAttributeValue.feedAttributeId = adCustomizerFeed.feedAttributes(2).id
dateAttributeValue.stringValue = dateValue
attributeValues.Add(dateAttributeValue)

feedItem.attributeValues = attributeValues.ToArray

feedItem.adGroupTargeting = New FeedItemAdGroupTargeting
feedItem.adGroupTargeting.TargetingAdGroupId = adGroupId

Os itens serão buscados somente para o grupo de anúncios especificado para o targeting_ad_group_id. Qualquer anúncio nesse grupo usará esses itens de feed para as substituições dinâmicas.

Se vários itens do feed têm correspondência em um determinado contexto, o sistema usa um algoritmo para escolher um automaticamente. Esse algoritmo pode variar com o tempo. Se você quiser ter um controle maior sobre quais itens do feed são usados em cada contexto, lembre-se de usar segmentação específica nos itens do feed.

Usar o feed em um anúncio

Quando o feed estiver configurado, você poderá referenciá-lo a partir de qualquer anúncio no sistema.

Ao configurar um anúncio, você faz referência a um feed e aos respectivos atributos por nome, não pelo código. Isso é diferente das outras etapas, onde você usa os códigos gerados pelo sistema.

A sintaxe para inserir um valor personalizado de um feed é {=FeedName.AttributeName}. Se você quiser especificar um valor padrão, a sintaxe deve ser {=FeedName.AttributeName:default value}. Por exemplo, usando nosso feed acima, se você quiser inserir o preço de um objeto na string com um valor padrão de "$10", use {=AdCustomizerFeed.Price:$10}:

Java

ExpandedTextAd textAd = new ExpandedTextAd();
textAd.setHeadlinePart1(String.format("Luxury Cruise to {=%s.Name}", feedName));
textAd.setHeadlinePart2(String.format("Only {=%s.Price}", feedName));
textAd.setDescription(String.format("Offer ends in {=countdown(%s.Date)}!", feedName));
textAd.setFinalUrls(new String[] {"http://www.example.com"});

CSharp

ExpandedTextAd expandedTextAd = new ExpandedTextAd() {
  headlinePart1 = string.Format("Luxury Cruise to {{={0}.Name}}", feedName),
  headlinePart2 = string.Format("Only {{={0}.Price}}", feedName),
  description = string.Format("Offer ends in {{=countdown({0}.Date)}}!", feedName),
  finalUrls = new string[] { "http://www.example.com" }
};

Python

expanded_text_ad = {
    'xsi_type': 'ExpandedTextAd',
    'headlinePart1': 'Luxury Cruise to {=%s.Name}' % feed_name,
    'headlinePart2': 'Only {=%s.Price}' % feed_name,
    'description': 'Offer ends in {=countdown(%s.Date)}!' % feed_name,
    'finalUrls': ['http://www.example.com'],
}

PHP

// Create an expanded text ad that uses ad customization.
$expandedTextAd = new ExpandedTextAd();
$expandedTextAd->setHeadlinePart1(
    sprintf('Luxury Cruise to {=%s.Name}', $feedName)
);
$expandedTextAd->setHeadlinePart2(
    sprintf('Only {=%s.Price}', $feedName)
);
$expandedTextAd->setDescription(
    sprintf('Offer ends in {=countdown(%s.Date)}!', $feedName)
);
$expandedTextAd->setFinalUrls(['http://www.example.com']);

Perl

my $text_ad = Google::Ads::AdWords::v201802::ExpandedTextAd->new({
    headlinePart1 => sprintf("Luxury Cruise to {=%s.Name}", $feed_name),
    headlinePart2 => sprintf("Only {=%s.Price}",            $feed_name),
    description =>
      sprintf("Offer ends in {=countdown(%s.Date)}!", $feed_name),
    finalUrls => ['http://www.example.com']});

Ruby

# All set! We can now create ads with customizations.
expanded_text_ad = {
  :xsi_type => 'ExpandedTextAd',
  :headline_part1 => 'Luxury Cruise to {=%s.Name}' % feed_name,
  :headline_part2 => 'Only {=%s.Price}' % feed_name,
  :description => 'Offer ends in {=countdown(%s.Date)}!' % feed_name,
  :final_urls => ['http://www.example.com']
}

VB.NET

Dim expandedTextAd As New ExpandedTextAd
expandedTextAd.headlinePart1 = String.Format("Luxury Cruise to {{={0}.Name}}", feedName)
expandedTextAd.headlinePart2 = String.Format("Only {{={0}.Price}}", feedName)
expandedTextAd.description = String.Format("Offer ends in {{=countdown({0}.Date)}}!",
                                         feedName)
expandedTextAd.finalUrls = New String() {"http://www.example.com"}

Se esse anúncio for adicionado por meio do AdGroupAdService, as referências a AdCustomizerFeed serão preenchidas no momento da veiculação com dados correspondentes de um item de um feed que corresponde ao grupo de anúncios atual. O anúncio não será veiculado se não for encontrada uma correspondência.

A API valida os anúncios que incluem referências a personalizadores de anúncios. Se nenhum feed com o nome especificado for mapeado ao tipo de marcador de posição do anúncio ou nenhum atributo com o nome especificado existir no feed, o anúncio será rejeitado.

Se você alterar o nome de um feed quando os anúncios fizerem referência a ele, os anúncios serão automaticamente atualizados para fazer referência ao novo nome do feed. Se você excluir um feed quando os anúncios fizerem referência a ele, esses anúncios não serão mais veiculados.

Os anúncios que usam personalizadores de anúncios estão sujeitos a aprovações, assim como os demais anúncios. Os itens do feed e os anúncios podem ser reprovados separadamente, embora a reprovação de qualquer um deles impeça a veiculação do anúncio. Em casos raros em que cada um individualmente está correto, mas a combinação dos dois gera uma violação, o anúncio será reprovado para impedir a veiculação.

Adicionar uma contagem regressiva

A função COUNTDOWN permite alterar dinamicamente a forma como você exibe um campo de data para que mostre o tempo (dias, horas) restante.

Por exemplo, a description do exemplo de anúncio acima é definida como 'Offer ends in {=COUNTDOWN(AdCustomizerFeed.Date)}!' No momento da veiculação, o anúncio mostrará "A oferta termina em 5 dias!" ou "A oferta termina em 4 horas!", dependendo do tempo restante.

Depois que passar a data especificada na contagem regressiva, o anúncio não será mais exibido até que a data seja atualizada novamente.

A função de contagem regressiva leva três argumentos, mas apenas o primeiro é obrigatório:

  • timestamp: A data de término da contagem regressiva. Esse valor pode ser uma referência a um atributo de feed ou a uma data literal específica.
  • language: O idioma no qual a contagem regressiva será exibida. Se não for especificado, o padrão será en-US.
  • days_before: O número de dias antes do timestamp em que o anúncio começará a ser veiculado. Por exemplo, se faltar seis dias para a data especificada, mas o campo estiver configurado como "5", o anúncio não será veiculado. Se não for especificado, nenhuma restrição será adicionada.

Por exemplo, você pode usar {=COUNTDOWN(AdCustomizerFeed.Date, 'es', 3)} para alterar o idioma para espanhol e restringir o anúncio de maneira que não seja exibido em resultados de pesquisa até três dias antes da data especificada.

A função COUNTDOWN faz a contagem regressiva até um evento no fuso horário do usuário que realiza a consulta. Uma variante de COUNTDOWN, chamada de GLOBAL_COUNTDOWN, faz a contagem regressiva até um horário específico no fuso horário da sua conta. GLOBAL_COUNTDOWN usa os mesmos parâmetros que COUNTDOWN.

Adicionar uma função IF

Com as funções IF, você pode inserir uma mensagem personalizada no seu anúncio com base em quem está pesquisando e em qual dispositivo está pesquisando, tudo sem usar um feed. O texto padrão é opcional.

Dimensão Critérios Sintaxe Exemplo
device mobile {=IF(device=mobile,text to insert):optional default text} {=IF(device=mobile,"Quick, Easy, Mobile Booking"):"Best price guarantee"}
audience Qualquer nome de lista de usuários válido na sua conta (se o nome da lista corresponder a várias listas na conta do anunciante, ele será escolhido aleatoriamente) {=IF(audience IN (userlist1,userlist2),text to insert):optional default text} {=IF(audience IN (returning visitors,cart abandoners),30%):25%}

Exemplos de código

Os exemplos de código em cada uma das linguagens suportadas podem ajudar nos primeiros passos:

Parâmetros do anúncio

Os parâmetros de anúncios permitem a atualização dinâmica de informações numéricas em um anúncio sem precisar reenviar o anúncio para análise e aprovação. É semelhante à inserção de palavras-chave, onde as marcações dentro do anúncio são atualizadas quando exibidas. Os parâmetros de anúncios são gerenciados pela API por meio do AdParamService.

Um parâmetro de anúncio é representado por um objeto AdParam. Para um AdParam funcionar corretamente:

  • ele precisa ser específico quanto a Keyword, AdGroup e paramIndex daquela impressão;
  • ele não pode fazer com que nenhum campo de texto do anúncio exceda o limite de tamanho da linha depois que todos os parâmetros do anúncio forem aplicados;
  • ele precisa fazer parte de um anúncio exibido na rede de pesquisa do Google.

Os valores padrão são mostrados para o parâmetro de anúncio se houver um problema durante a inserção.

Exemplos de código

Os exemplos de código em cada uma das linguagens suportadas podem ajudar nos primeiros passos:

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.