Remarketing e segmentação por público-alvo

O remarketing permite exibir publicidade para pessoas que já acessaram seu website, usaram seu aplicativo para dispositivos móveis ou que estão nos seus bancos de dados de Gerenciamento de relacionamento com clientes (CRM). Para fazer isso, ele exibe anúncios relevantes a essas pessoas quando elas acessam outros sites ou pesquisam no Google. As listas de usuários usadas no remarketing também podem ser empregadas em outros tipos de segmentação por público-alvo, como a Segmentação por lista de clientes.

Este guia trata de:

As informações confidenciais sobre os usuários não podem ser usadas para criar listas de remarketing. Antes de configurar uma campanha de remarketing e inserir a tag de remarketing no seu website ou aplicativo, leia atentamente a Política de publicidade com base em interesses e local.

Tipos de público-alvo em uma UserList

É possível fazer remarketing e segmentar públicos-alvo específicos com uma UserList. A lista pode ser criada a partir de diferentes tipos de públicos-alvo:

Visitantes do seu website

O tipo mais simples de lista de público-alvo é composto por visitantes do seu website. Algumas estratégias de segmentação mais avançadas (descritas abaixo) podem, por exemplo, adaptar anúncios de modo a segmentar apenas as pessoas que visitaram uma página ou combinação de páginas específica no seu website recentemente.

Todas as contas do Google AdWords têm exatamente uma tag de remarketing no nível da conta, criada automaticamente quando a conta é aberta. A tag fica disponível mesmo que você ainda não tenha começado a usar o remarketing. O primeiro passo é recuperar sua tag de remarketing no nível da conta usando CustomerService:

// Get the customer service.
CustomerServiceInterface customerService =
    adWordsServices.get(session, CustomerServiceInterface.class);

// Retrieve the Customer object for the session. Make sure
// that the session's clientCustomerId is set to your account's
// ID.
Customer customer = customerService.getCustomers()[0];

// Print the account level remarketing tag.
System.out.printf("Customer ID %s has remarketing tag:%n%s%n",
    customer.getCustomerId(),
    customer.getRemarketingSettings().getSnippet());

O próximo passo é instalar sua tag de remarketing no nível da conta em todas as páginas do seu site. Saiba mais sobre como adicionar a tag de remarketing ao seu site ou aplicativo para dispositivo móvel nesse artigo da Central de Ajuda do Google AdWords.

Você também pode usar o Assistente de tags do Google no Chrome para validar a instalação da sua tag.

Em seguida, crie uma lista de usuários incluindo as pessoas que acionaram a tag de remarketing. Você cria e gerencia as listas de usuários com AdwordsUserListService. Existem diversos tipos de listas de usuários com características diferentes. Para criar uma lista que registra todos que visitaram qualquer página do seu website, use um ExpressionRuleUserList, como mostrado abaixo, em que o URL da página visitada inclui o domínio do seu website. Consulte Remarketing com base em regras para ver mais detalhes sobre o uso de listas de remarketing com base em regras.

// Get the user list service.
AdwordsUserListServiceInterface userListService =
    adWordsServices.get(session, AdwordsUserListServiceInterface.class);

// Use built-in parameter to create domain URL rule.
StringKey urlKey = new StringKey("url__");

StringRuleItem urlStringRuleItem = new StringRuleItem();
urlStringRuleItem.setKey(urlKey);
urlStringRuleItem.setOp(StringRuleItemStringOperator.CONTAINS);
urlStringRuleItem.setValue("example.com");

RuleItem urlRuleItem = new RuleItem();
urlRuleItem.setStringRuleItem(urlStringRuleItem);

RuleItemGroup ruleItemGroup = new RuleItemGroup();
ruleItemGroup.setItems(new RuleItem[] {urlRuleItem});

Rule rule = new Rule();
rule.setGroups(new RuleItemGroup[] {ruleItemGroup});

// Create the user list.
ExpressionRuleUserList expressionUserList = new ExpressionRuleUserList();
expressionUserList.setName("All visitors to example.com");
expressionUserList.setDescription("Any visitor to any page of example.com");
expressionUserList.setRule(rule);
expressionUserList.setMembershipLifeSpan(365L);
expressionUserList.setStatus(UserListMembershipStatus.OPEN);

// Optional: To include past users in the user list, set the
// prepopulationStatus to REQUESTED.
expressionUserList.setPrepopulationStatus(
    RuleBasedUserListPrepopulationStatus.REQUESTED);

// Create and submit the operation.
UserListOperation operation = new UserListOperation();
operation.setOperator(Operator.ADD);
operation.setOperand(expressionUserList);

UserListReturnValue result =
    userListService.mutate(new UserListOperation[] {operation});
Long userListId = result.getValue(0).getId();

Os atributos membershipLifeSpan e status são importantes em uma lista de usuários. O primeiro permite que você defina o período, em dias, durante o qual um usuário é considerado parte da lista. O segundo define se a lista aceitará novos usuários.

A etapa final é segmentar anúncios para os membros da sua lista de usuários. O processo é semelhante àquele de outros tipos de critérios de segmentação na API. O código a seguir mostra como você pode usar um CriterionUserList para segmentar os anúncios de um grupo de anúncios para uma lista de usuários:

// Get the ad group criterion service.
AdGroupCriterionServiceInterface adGroupCriterionService =
    adWordsServices.get(session, AdGroupCriterionServiceInterface.class);

// Create user list criterion.
CriterionUserList userListCriterion = new CriterionUserList();
userListCriterion.setUserListId(userListId);

// Create biddable ad group criterion.
BiddableAdGroupCriterion biddableCriterion = new BiddableAdGroupCriterion();
biddableCriterion.setAdGroupId(adGroupId);
biddableCriterion.setCriterion(userListCriterion);

// Create operation.
AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
operation.setOperand(biddableCriterion);
operation.setOperator(Operator.ADD);

AdGroupCriterionOperation[] operations =
    new AdGroupCriterionOperation[] {operation};

// Apply the criterion.
AdGroupCriterionReturnValue result = adGroupCriterionService.mutate(operations);

A exemplo de outros tipos de critério, é possível atribuir outras propriedades ao objeto BiddableAdGroupCriterion, como sobreposições de lances.

Para alterar os critérios de lista de usuários do nível do grupo de anúncios para o nível da campanha, remova primeiro os critérios de lista de usuários existentes de todos os grupos de anúncios ativados ou pausados nessa campanha:

// Create selector for all user list criteria.
SelectorBuilder builder = new SelectorBuilder();
Selector selector = builder
    .fields(AdGroupCriterionField.Id)
    .equals(AdGroupCriterionField.AdGroupId, adGroupId)
    .equals(AdGroupCriterionField.CriteriaType, "USER_LIST")
    .build();

AdGroupCriterionServiceInterface criterionService =
    new AdWordsServices().get(session, AdGroupCriterionServiceInterface.class);

AdGroupCriterionPage page = criterionService.get(selector);

List<AdGroupCriterionOperation> operations =
    new ArrayList<AdGroupCriterionOperation>();

// Create remove operation for each user list.
for(AdGroupCriterion criterion : page.getEntries()){
  Long criterionId = criterion.getCriterion().getId();

  // Create user list criterion and specify the criterion ID to remove.
  CriterionUserList userListCriterion = new CriterionUserList();
  userListCriterion.setId(criterionId);

  // Create biddable ad group criterion.
  BiddableAdGroupCriterion biddableCriterion = new BiddableAdGroupCriterion();
  biddableCriterion.setAdGroupId(adGroupId);
  biddableCriterion.setCriterion(userListCriterion);

  // Create remove operation.
  AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
  operation.setOperand(biddableCriterion);
  operation.setOperator(Operator.REMOVE);

  operations.add(operation);
}

// Remove the criteria.
AdGroupCriterionReturnValue result =
    adGroupCriterionService.mutate(
    operations.toArray(new AdGroupCriterionOperation[operations.size()]));

Os critérios de lista de usuários existentes no nível da campanha também devem ser removidos ao alterar para listas de usuários no nível do grupo de anúncios, e o processo reflete o exemplo mostrado acima. O código da lista de usuários subjacente do critério não é criterionId.

A segmentação dos anúncios de uma campanha para uma lista de usuários é feita da mesma forma:

// Get the campaign criterion service.
CampaignCriterionServiceInterface campaignCriterionService =
    adWordsServices.get(session, CampaignCriterionServiceInterface.class);

// Create user list criterion.
CriterionUserList userListCriterion = new CriterionUserList();
userListCriterion.setUserListId(userListId);

// Create campaign criterion.
CampaignCriterion campaignCriterion = new CampaignCriterion();
campaignCriterion.setCampaignId(campaignId);
campaignCriterion.setCriterion(userListCriterion);

// Create operation.
CampaignCriterionOperation operation = new CampaignCriterionOperation();
operation.setOperand(campaignCriterion);
operation.setOperator(Operator.ADD);

CampaignCriterionOperation[] operations =
    new CampaignCriterionOperation[] {operation};

// Apply the criterion.
CampaignCriterionReturnValue result = campaignCriterionService.mutate(operations);

Visitantes de páginas específicas

É possível segmentar as pessoas que visitaram páginas ou seções específicas do seu website usando um ExpressionRuleUserList de modo semelhante ao exemplo acima, mas segmentando URLs mais específicos, e não apenas o domínio do seu website. Consulte Remarketing com base em regras abaixo para ver um exemplo e mais detalhes.

Visitantes que realizaram ações específicas

É possível preencher sua lista de públicos-alvo com pessoas que realizaram ações específicas no seu website. Se você estiver usando o acompanhamento de conversões, poderá segmentar anúncios para as pessoas que acionaram uma conversão (como uma compra) no seu website.

Você também pode segmentar anúncios para as pessoas que realizaram uma determinada ação no seu website que você não considera como uma conversão, por exemplo, quando uma pessoa adiciona, mas, em seguida, exclui um item do carrinho de compras sem finalizar a compra. BasicUserList inclui esses dois casos de uso.

Acionaram uma conversão

Se você ainda não tiver criado um rastreador de conversão, poderá fazer isso usando ConversionTrackerService. Em seguida, você poderá instalar o snippet do rastreador de conversão no seu website.

Um BasicUserList inclui pessoas que acionaram um ou mais rastreadores de conversão no seu website. Ao criar um BasicUserList, você fornece o valor do campo id no ConversionTracker que deseja associar à lista de usuários.

O exemplo a seguir cria um BasicUserList associado a dois rastreadores de conversão existentes:

AdwordsUserListServiceInterface userListService =
    adWordsServices.get(session, AdwordsUserListServiceInterface.class);

// Indicate the conversion trackers we want to associate with a new user list
UserListConversionType conversionType1 = new UserListConversionType();
conversionType1.setId(conversionTrackerId1);

UserListConversionType conversionType2 = new UserListConversionType();
conversionType2.setId(conversionTrackerId2);

// Create a basic user list associated with the two conversion trackers.
BasicUserList userList = new BasicUserList();
userList.setName("Example BasicUserList");
userList.setDescription("A list of people who have triggered conversion #1 or #2");
userList.setMembershipLifeSpan(365L);
userList.setConversionTypes(new UserListConversionType[] {conversionType1, conversionType2});
userList.setStatus(UserListMembershipStatus.OPEN);

// Create operation.
UserListOperation operation = new UserListOperation();
operation.setOperand(userList);
operation.setOperator(Operator.ADD);

UserListOperation[] operations = new UserListOperation[] {operation};

// Add user list.
UserListReturnValue result = userListService.mutate(operations);

Ações de não conversão

É possível criar um BasicUserList para as pessoas que realizaram ações que você não considera como conversões no seu website. Para isso, basta associá-lo a um ConversionTracker com uma categoria REMARKETING.

Existem duas maneiras de criar esse objeto ConversionTracker. Primeiro, você pode usar diretamente ConversionTrackerService ou pode criá-lo automaticamente pelo Google AdWords ao mesmo tempo que cria o BasicUserList associado. O código a seguir ilustra o segundo método:

UserListConversionType conversionType = new UserListConversionType();
conversionType.setName("Remarketing-only conversion tracker");

// Create basic user list.
BasicUserList userList = new BasicUserList();
userList.setName("Example BasicUserList Remarketing Only");
userList.setDescription("Triggered an action not considered a conversion");
userList.setMembershipLifeSpan(365L);
userList.setConversionTypes(new UserListConversionType[] {conversionType});
userList.setStatus(UserListMembershipStatus.OPEN);

// Same as previous example
...

Há um UserListConversionType vinculado à lista, mas nenhum id foi definido. Isso aciona a geração automática de um objeto ConversionTracker de categoria REMARKETING.

É possível recuperar o snippet de código para o objeto ConversionTracker gerado automaticamente:

// From the user list creation obtain the tracker ID.
String conversionId = userList.getConversionTypes().get(0).getId().toString();

// Create predicate and selector.
Predicate predicate = new Predicate();
predicate.setField("Id");
predicate.setOperator(PredicateOperator.IN);
predicate.setValues(new String [] {conversionId});
Selector selector = new Selector();
selector.setFields(new String[] {"Id"});
selector.setPredicates(new Predicate[] {predicate});

// Get the conversion tracker.
ConversionTrackerPage page = conversionTrackerService.get(selector);

// Print out the conversion tracker code snippet.
System.out.println(((AdWordsConversionTracker) page.getEntries()[0]).getSnippet());

Várias listas de usuários

Você pode criar combinações personalizadas de listas de usuários existentes como um LogicalUserList com campos UserListLogicalRule. As regras no LogicalUserList têm operandos AND. Assim, um usuário precisa corresponder a todas as regras para ser inserido na lista. No entanto, cada regra permite que você especifique se os operandos são AND ou OR. Em outras palavras, é possível especificar se o usuário precisa preencher TODOS os operandos das regras ou apenas um deles.

Além disso, as regras permitem que você especifique outros objetos LogicalUserList como operandos, permitindo efetivamente a criação de uma árvore deles. O uso de LogicalUserList é uma maneira muito eficiente de definir hierarquias complexas de grupos para a sua segmentação. Você pode combinar listas com campos AccessReason diferentes. No entanto, se o acesso for revogado, o UserList será tratado como uma lista sem membros quando as regras de LogicalUserList forem avaliadas.

O código a seguir mostra como criar um LogicalUserList que contém usuários em um dos dois BasicUserList:

// My basic user list of Mars customers.
BasicUserList basicMarsList = new BasicUserList();
basicMarsList.setId(...);

// My basic user list of Venus customers.
BasicUserList basicVenusList = new BasicUserList();
basicVenusList.setId(...);

LogicalUserListOperand marsListOperand = new LogicalUserListOperand();
marsListOperand.setUserList(basicMarsList);

LogicalUserListOperand venusListOperand = new LogicalUserListOperand();
venusListOperand.setUserList(basicVenusList);

UserListLogicalRule rule = new UserListLogicalRule(
    UserListLogicalRuleOperator.ANY,
    new LogicalUserListOperand[] {marsListOperand, venusListOperand});

// Create logical user list.
LogicalUserList combinationList = new LogicalUserList();
combinationList.setName("My combination list of Mars or Venus customers #"
    + System.currentTimeMillis());
combinationList.setRules(new UserListLogicalRule[] {rule});

// Create operations.
UserListOperation operation = new UserListOperation();
operation.setOperand(combinationList);
operation.setOperator(Operator.ADD);

UserListOperation[] operations = new UserListOperation[] {operation};

// Add logical user list.
UserListReturnValue result = userListService.mutate(operations);

Públicos-alvo semelhantes

Um modo de alcançar novos públicos-alvo é com o uso de um SimilarUserList. Com esta lista de usuários, é possível segmentar as pessoas que compartilham características com outras pessoas nas suas outras listas de usuários.

Para cada UserList, um SimilarUserList é gerado automaticamente pelo Google com base em vários fatores, por exemplo, o número de pessoas na lista original, há quanto tempo eles entraram na lista, os tipos de sites que eles navegaram e se a lista é sua. Esse processo pode levar até quatro dias a partir da criação da lista de origem.

O código a seguir mostra como localizar todos os objetos SimilarUserList disponíveis:

AdwordsUserListServiceInterface userListService =
    adWordsServices.get(session, AdwordsUserListServiceInterface.class);

UserListPage page = userListService.get(
    new SelectorBuilder()
    .fields("Id", "Name", "SeedUserListId")
    .equals("ListType", UserListType._SIMILAR)
    .build());

for (UserList userlist : page.getEntries()) {
  System.out.printf("id: %d, name: %s, seed list id: %d%n",
      userlist.getId(),
      userlist.getName(),
      ((SimilarUserList)userlist).getSeedUserListId());
}

Segmentação por lista de clientes com endereços de e-mail

Para os anunciantes que têm bancos de dados de CRM ricos, é possível definir e segmentar as listas de público-alvo com base nos seus dados de e-mail de CRM. Você pode fazer o upload de endereços de e-mail em massa, acrescentar/remover endereços de e-mail ou usar essas listas de usuários para criar um LogicalUserList.

Essas listas de público-alvo são qualificadas para veiculação na Pesquisa Google, no YouTube e no Gmail, mas não estarão disponíveis na Rede de Display do Google.

De acordo com a política, você só tem permissão para fazer o upload de endereços de e-mail que você mesmo tenha adquirido (e-mails próprios). Não é permitido comprar listas de e-mail de terceiros e fazer upload delas na conta.

Por questões de privacidade, os endereços de e-mail precisam receber hash usando o algoritmo SHA-256 antes do upload. Por esse motivo, antes de colocar hash em um endereço de e-mail, é necessário:

  • remover espaços em branco no início ou no final do campo;

  • usar somente letras minúsculas no endereço de e-mail.

O código a seguir mostra como criar um CrmBasedUserList e adicionar três membros com base em três endereços de e-mail diferentes que foram normalizados e receberam hash de forma adequada.

private static final ImmutableList<String> EMAILS =
    ImmutableList.of("client1@example.com", "client2@example.com", " Client3@example.com ");
private static final MessageDigest digest = getSHA256MessageDigest();

// Get the UserListService.
AdwordsUserListServiceInterface userListService =
    adWordsServices.get(session, AdwordsUserListServiceInterface.class);

// Create a user list.
CrmBasedUserList userList = new CrmBasedUserList();
userList.setName("Customer relationship management list #" + System.currentTimeMillis());
userList.setDescription("A list of customers that originated from email addresses");

// See limit here: https://support.google.com/adwords/answer/6276125#requirements.
userList.setMembershipLifeSpan(30L);

// Create operation.
UserListOperation operation = new UserListOperation();
operation.setOperand(userList);
operation.setOperator(Operator.ADD);

// Add user list.
UserListReturnValue result = userListService.mutate(new UserListOperation[] { operation });

// Display user list.
UserList userListAdded = result.getValue(0);
System.out.printf("User list with name '%s' and ID %d was added.%n",
    userListAdded.getName(), userListAdded.getId());

// Get user list ID.
Long userListId = userListAdded.getId();

// Create operation to add members to the user list based on email addresses.
MutateMembersOperation mutateMembersOperation = new MutateMembersOperation();
MutateMembersOperand operand = new MutateMembersOperand();
operand.setUserListId(userListId);

// You can optionally provide this field.
operand.setDataType(MutateMembersOperandDataType.EMAIL_SHA256);

// Hash normalized email addresses based on SHA-256 hashing algorithm.
List<String> emailHashes = new ArrayList<>(EMAILS.size());
for (String email : EMAILS) {
  String normalizedEmail = toNormalizedEmail(email);
  emailHashes.add(toSHA256String(normalizedEmail));
}

// Add email address hashes.
operand.setMembers(emailHashes.toArray(new String[emailHashes.size()]));
mutateMembersOperation.setOperand(operand);
mutateMembersOperation.setOperator(Operator.ADD);

// Add members to the user list based on email addresses.
MutateMembersReturnValue mutateMembersResult =
    userListService.mutateMembers(new MutateMembersOperation[] { mutateMembersOperation });

// Display results.
// Reminder: it may take several hours for the list to be populated with members.
for (UserList userListResult : mutateMembersResult.getUserLists()) {
  System.out.printf("%d email addresses were uploaded to user list with name '%s' and ID %d "
      + "and are scheduled for review.%n",
      EMAILS.size(), userListResult.getName(), userListResult.getId());
}

/**
 * Hash a string using SHA-256 hashing algorithm.
 *
 * @param str the string to hash.
 * @return the SHA-256 hash string representation.
 * @throws UnsupportedEncodingException If UTF-8 charset is not supported.
 */
private static String toSHA256String(String str) throws UnsupportedEncodingException {
  byte[] hash = digest.digest(str.getBytes("UTF-8"));
  StringBuilder result = new StringBuilder();
  for (byte b : hash) {
    result.append(String.format("%02x", b));
  }

  return result.toString();
}

/**
 * Removes leading and trailing whitespace and converts all characters to lower case.
 *
 * @param email the email address to normalize.
 * @return a normalized copy of the string.
 */
private static String toNormalizedEmail(String email) {
  return email.trim().toLowerCase();
}

/** Returns SHA-256 hashing algorithm. */
private static MessageDigest getSHA256MessageDigest() {
  try {
    return MessageDigest.getInstance("SHA-256");
  } catch (NoSuchAlgorithmException e) {
    throw new RuntimeException("Missing SHA-256 algorithm implementation.", e);
  }
}

Existem diversas opções de Segmentação por lista de clientes em diferentes tipos de campanha:

Campanhas Apenas na rede de pesquisa
É disponibilizado um CrmBasedUserList. Os anúncios serão exibidos na rede de pesquisa.
Campanhas apenas na Rede de Display
São disponibilizados um CrmBasedUserList e seu respectivo SimilarUserList. Os anúncios serão exibidos no Gmail apenas se houver criativos de PPG (Promoções Patrocinadas no Gmail).
Campanhas Rede de pesquisa com exibição em Display
É disponibilizado um CrmBasedUserList. Os anúncios serão exibidos na rede de pesquisa e no Gmail (somente se houver criativos de PPG).
Campanhas de vídeo
São disponibilizados um CrmBasedUserList e seu respectivo SimilarUserList. Os anúncios serão exibidos no YouTube apenas se houver anúncios TrueView in-stream.

Ressalvas

  • A API impõe um limite no número de endereços de e-mail em cada solicitação de mutação.

  • O limite de MembershipLifeSpan pode ser diferente de outras listas de usuários.

  • O preenchimento da lista com os membros pode levar várias horas.

  • Os endereços de e-mail precisam estar associados a uma Conta do Google.

  • Somente endereços @gmail.com podem ser usados para a segmentação no Gmail.

  • Para fins de privacidade, o tamanho da lista de usuários será exibido como zero até que a lista tenha pelo menos 1.000 membros. Depois disso, o tamanho será arredondado para os dois dígitos mais significativos.

  • É recomendável fazer upload de pelo menos 5.000 endereços de e-mail para a lista como um modo de garantir que os anúncios comecem a ser veiculados.

  • Quando um LogicalUserList é usado, só é possível combinar um CrmBasedUserList com outro CrmBasedUserList. Todas as políticas de CrmBasedUserList serão aplicadas à lista de usuários resultante.

Configurações de segmentação para remarketing

Depois que você adicionar uma lista de usuários a um grupo de anúncios ou a uma campanha como critério, ela estará pronta para uso. No entanto, é possível que a segmentação não esteja exatamente como você deseja. Para verificar se a segmentação está funcionando corretamente, confira o TargetingSetting em grupos de anúncios ou campanhas que usam a nova lista chamando seus métodos getSettings.

É possível configurar detalhes sobre como seus vários tipos de critério são usados para segmentação com uma série de objetos TargetingSettingDetail. Cada TargetingSettingDetail permite controlar se um tipo de critérios usa o esquema Bid only ou Target and bid.

Com o uso de Bid only, os critérios não serão usados para restringir o tráfego, mas permitirão que você defina lances diferentes para usuários diversos nas suas listas. O esquema Target and bid permite que os critérios restrinjam o tráfego do grupo de anúncios somente para os usuários na lista segmentada.

A segmentação padrão das listas de remarketing é Target and bid. Se você adicionar listas de remarketing à sua principal campanha de pesquisa, considere a possibilidade de alterar a configuração de segmentação para Bid only. Se você configurar uma campanha duplicada de listas de remarketing para anúncios da rede de pesquisa, mantenha a segmentação como Target and bid.

Veja um exemplo que usa a biblioteca cliente Java para definir o TargetingSettingDetail como Bid only em um grupo de anúncios:

AdGroup adGroup = ... // fetch the ad group relevant for this case

List<Setting> settings = Lists.newArrayList();
List<TargetingSettingDetail> details = Lists.newArrayList();
TargetingSetting targetingSetting = null;
if (adGroup.getSettings() != null) {
  // Find the existing TargetingSetting if it exists, and keep
  // track of all other settings.
  for (Setting setting : adGroup.getSettings()) {
    if (setting instanceof TargetingSetting) {
      targetingSetting = (TargetingSetting) setting;
    } else {
      settings.add(setting);
    }
  }

  if (targetingSetting != null) {
    // Copy all the existing TargetingSettingDetails except the one for
    // USER_INTEREST_AND_LIST.
    for (TargetingSettingDetail settingDetail : targetingSetting.getDetails()) {
      if (!CriterionTypeGroup.USER_INTEREST_AND_LIST.equals(
              settingDetail.getCriterionTypeGroup())) {
        details.add(settingDetail);
      }
    }
  }
}

if (targetingSetting == null) {
  targetingSetting = new TargetingSetting();
}

// Create a new USER_INTEREST_AND_LIST targeting setting detail and add
// it to the details list.
TargetingSettingDetail userListsSetting = new TargetingSettingDetail();
userListsSetting.setCriterionTypeGroup(CriterionTypeGroup.USER_INTEREST_AND_LIST);

// true = "Bid only"; false = "Target and bid"
userListsSetting.setTargetAll(true);
details.add(userListsSetting);

targetingSetting.setDetails(details.toArray(new TargetingSettingDetail[details.size()]));

// Add the new TargetingSetting for USER_INTEREST_AND_LIST to the settings list.
settings.add(targetingSetting);

adGroup.setSettings(settings.toArray(new Setting[settings.size()]));

O processo para definir Bid only ou Target and bid nas campanhas é quase idêntico. Use os métodos setSettings e setSettings de um objeto Campaign da mesma forma mostrada para AdGroup.

Relatórios de desempenho

O Relatório de desempenho do público-alvo indica os campos necessários para coletar os relatórios de desempenho das suas listas de usuários. Por exemplo, você pode analisar o Conversions ou o CostPerConversion nesse relatório para determinar se a segmentação dos membros da lista está realmente gerando mais conversões e, em seguida, ajustar seus modificadores de lances de modo adequado. Também é possível ver a lista de usuários por clique incluindo o campo UserListId no Relatório de desempenho de cliques. Consulte a guia Relatórios para ver mais detalhes.

Remarketing com listas de usuários com base em regras

As listas de usuários com base em regras permitem definir um público-alvo de segmentação para os seus anúncios com base em parâmetros integrados da tag de remarketing ou parâmetros personalizados adicionados à sua tag de remarketing. Depois de configurar uma lista de usuários corretamente e adicionar a tag de remarketing ao seu site ou aplicativo para dispositivos móveis, você pode segmentar os usuários na lista, definir lances de modo diferente para os usuários e gerar relatórios que organizam ou filtram as estatísticas com base nos membros da lista.

Como esta seção tem foco em listas com base em regras, ela contém exemplos da criação de ExpressionRuleUserList e DateSpecificRuleUserList.

As informações confidenciais sobre os usuários não podem ser usadas para criar listas de remarketing. Antes de configurar uma campanha de remarketing e inserir a tag de remarketing no seu website ou aplicativo, leia atentamente nossa página sobre publicidade personalizada.

Como usar os parâmetros integrados da tag de remarketing

Use o parâmetro integrado de remarketing url__ para segmentar uma lista de usuários com base nos URLs que as pessoas visitaram no seu website. Por exemplo, o código abaixo mostra como criar uma lista de usuários com base em regras para as pessoas que visitaram páginas em duas seções diferentes do seu website. O uso de um parâmetro integrado de remarketing não requer edições na sua tag de remarketing.

StringKey urlKey = new StringKey("url__");

StringRuleItem urlStringRuleItem1 = new StringRuleItem();
urlStringRuleItem1.setKey(urlKey);
urlStringRuleItem1.setOp(StringRuleItemStringOperator.CONTAINS);
urlStringRuleItem1.setValue("example.com/section1/");

RuleItem urlRuleItem1 = new RuleItem();
urlRuleItem1.setStringRuleItem(urlStringRuleItem1);

StringRuleItem urlStringRuleItem2 = new StringRuleItem();
urlStringRuleItem2.setKey(urlKey);
urlStringRuleItem2.setOp(StringRuleItemStringOperator.CONTAINS);
urlStringRuleItem2.setValue("example.com/section2/");

RuleItem urlRuleItem2 = new RuleItem();
urlRuleItem2.setStringRuleItem(urlStringRuleItem2);

// Combine the two rule items into a RuleItemGroup so AdWords will AND their
// rules together. To instead OR the rules together, each RuleItem should be
// placed in its own RuleItemGroup.
RuleItemGroup ruleItemGroup = new RuleItemGroup();
ruleItemGroup.setItems(new RuleItem[] {urlRuleItem1, urlRuleItem2});

Rule rule = new Rule();
rule.setGroups(new RuleItemGroup[] {ruleItemGroup});

// Create the user list.
ExpressionRuleUserList expressionUserList = new ExpressionRuleUserList();
expressionUserList.setName("Sections 1 and 2"));
expressionUserList.setDescription("Visitors to section1 or section2");
expressionUserList.setRule(rule);

Como usar parâmetros de tag de remarketing personalizados

Você pode adicionar parâmetros de tag de remarketing personalizados à sua tag de remarketing para criar listas de usuários mais adaptadas às suas necessidades.

Cenário

Digamos que você tenha um site para o qual configurou vários parâmetros de tag de remarketing personalizados para capturar os seguintes atributos de usuários:

  • ecomm_pagetype: a categoria de página no seu site, como finalização da compra, carrinho de compras etc.
  • cartsize: o número de itens no carrinho de compras de um usuário.
  • checkoutdate: a data em que um usuário finalizou a compra. Você define esse parâmetro somente quando um usuário realmente concluiu a compra.

Você tem interesse em exibir mais impressões para os usuários que colocaram vários itens nos carrinhos de compras e iniciaram o processo de finalização da compra. Também convém encontrar usuários que fizeram uma compra durante novembro e dezembro, porque você pretende promover uma grande promoção no seu site durante esses meses.

É possível descrever esse conjunto de usuários com uma das seguintes regras:

  1. Usuários que visitaram a página de finalização da compra e tinham mais de um item no carrinho.
  2. Usuários que finalizaram a compra durante os meses de novembro e dezembro.

Se um usuário se enquadrar em uma das duas categorias, aumente seus lances em campanhas ou grupos de anúncios específicos em 25%.

Visão geral dos objetos

Antes de analisar o código, vejamos a estrutura de uma lista de usuários com base em regras. Uma lista com base em regras é representada na Google AdWords API como um RuleBasedUserList. O diagrama abaixo mostra a aparência que o RuleBasedUserList teria nesse caso de uso após concluir a codificação.

Diagrama da estrutura de uma lista de usuários com base em regras

Criar o primeiro RuleItemGroup

Vamos começar com a criação do primeiro RuleItemGroup à esquerda, que é composto por dois exemplares de RuleItem:

  1. Usuários que visitaram a página de finalização da compra.
  2. Usuários com mais de um item no seu carrinho de compras.

O primeiro item usa o parâmetro ecomm_pagetype que tem valores de string. Dessa forma, convém criar um StringRuleItem primeiro.

StringRuleItem checkoutStringRuleItem = new StringRuleItem(
    new StringKey("ecomm_pagetype"), StringRuleItemStringOperator.EQUALS, "checkout");
RuleItem checkoutRuleItem = new RuleItem();
checkoutRuleItem.setStringRuleItem(checkoutStringRuleItem);

O segundo item usa o parâmetro cartsize que tem valores numéricos. Assim, você precisará de um NumberRuleItem.

NumberRuleItem cartSizeNumberRuleItem = new NumberRuleItem(
    new NumberKey("cartsize"), NumberRuleItemNumberOperator.GREATER_THAN, 1.0);
RuleItem cartSizeRuleItem = new RuleItem();
cartSizeRuleItem.setNumberRuleItem(cartSizeNumberRuleItem);

Em seguida, combine os dois RuleItems em um RuleItemGroup. Quando os itens são combinados em um grupo de itens, o Google AdWords usará AND para juntar suas regras.

RuleItemGroup checkoutMultipleItemGroup = new RuleItemGroup();
checkoutMultipleItemGroup.setItems(new RuleItem[] {checkoutRuleItem, cartSizeRuleItem});

Criar o segundo RuleItemGroup

O RuleItemGroup à direita consiste em dois objetos RuleItem:

  1. usuários que finalizaram a compra após 31 de outubro
  2. usuários que finalizaram a compra antes de 1º de janeiro

Esses dois itens usam o parâmetro checkoutdate que tem valores de data. Por isso, desta vez você criará objetos DateRuleItem.

// Create the RuleItem for the start date.
DateRuleItem startDateDateRuleItem = new DateRuleItem(
    new DateKey("checkoutdate"),
    DateRuleItemDateOperator.AFTER, "20141031");
RuleItem startDateRuleItem = new RuleItem();
startDateRuleItem.setDateRuleItem(startDateDateRuleItem);

// Create the RuleItem for the end date.
DateRuleItem endDateDateRuleItem = new DateRuleItem(
    new DateKey("checkoutdate"),
    DateRuleItemDateOperator.BEFORE, "20150101");
RuleItem endDateRuleItem = new RuleItem();
endDateRuleItem.setDateRuleItem(endDateDateRuleItem);

Como no grupo à esquerda, combine esses dois objetos RuleItem em um RuleItemGroup com AND.

RuleItemGroup checkedOutNovDecItemGroup = new RuleItemGroup();
checkedOutNovDecItemGroup.setItems(new RuleItem[] {startDateRuleItem, endDateRuleItem});

Criar a lista de usuários

O que fica faltando é combinar os grupos de itens da regra acima em uma nova lista de usuários.

// Create the user list.
ExpressionRuleUserList expressionUserList = new ExpressionRuleUserList();
expressionUserList.setName("My expression rule user list");
expressionUserList.setDescription("Users who checked out in November or December "
    + "OR visited the checkout page with more than one item in their cart");

// OR the RuleItemGroups together into a Rule.
Rule rule = new Rule();
rule.setGroups(new RuleItemGroup[] {checkoutMultipleItemGroup, checkedOutNovDecItemGroup});
expressionUserList.setRule(rule);

// Set other optional attributes of the user list.
...

// Create an operation to ADD the user list.
UserListOperation operation = new UserListOperation();
operation.setOperator(Operator.ADD);
operation.setOperand(expressionUserList);

// Submit the operation.
UserListReturnValue result =
    adwordsUserListService.mutate(new UserListOperation[] {operation});

Limite por período de visita ao site

O ExpressionRuleUserList acima atende às suas necessidades, mas e se você quiser apenas capturar os usuários que cumprem a regra nessa lista e visitam seu site entre 1º de outubro e 31 de dezembro? Use DateSpecificRuleUserList.

Para criar um DateSpecificUserList, siga o mesmo procedimento usado para criar um ExpressionRuleUserList, mas defina também o startDate e o endDate da lista.

DateSpecificRuleUserList dateRuleUserList = new DateSpecificRuleUserList();
dateRuleUserList.setStartDate(startDate.toString("20141001"));
dateRuleUserList.setEndDate(endDate.toString("20141231"));

// Set optional attributes of the user list, such as membershipLifeSpan or
// integration code.
...

// Use the same rule defined above.
dateRuleUserList.setRule(rule);

Isso é tudo. A nova lista conterá todos os usuários que cumpram as mesmas regras da lista anterior, mas somente se eles visitam seu site entre startDate e endDate (as duas datas são inclusivas). Consulte a documentação DateSpecificRuleUserList para ver outras opções, como datas de início ou término abertas.

Incluir usuários anteriores na lista

A partir da versão v201702, você também pode incluir usuários anteriores em uma lista de usuários com base em regras definindo o prepopulationStatus da lista de usuários como REQUESTED, além de monitorar o progresso do processo de pré-preenchimento assíncrono verificando periodicamente o status desse campo.

Modificar lances para os usuários na lista

Você criou uma lista de usuários e configurou a tag de remarketing no seu site. Agora, segmente especificamente os membros da lista nos seus grupos de anúncios ou campanhas aumentando seus lances em 25%.

Vamos modificar os lances de um conjunto de grupos de anúncios:

// Specify the ad group IDs.
List<Long> adGroupIds = Lists.newArrayList(
    // ad group ID 1,
    // ad group ID 2,
    // ...
    );

// Create a CriterionUserList that points to the user list created above.
CriterionUserList criterionUserList = new CriterionUserList();
criterionUserList.setUserListId(dateRuleUserList.getId());

List<AdGroupCriterionOperation> operations = Lists.newArrayList();
for(Long adGroupId : adGroupIds) {
  // Create a BiddableAdGroupCriterion for the CriterionUserList and set
  // its bid modifier to 1.25. Instead of specifying a bid modifier, you
  // could set the BiddableAdGroupCriterion's bidding strategy configuration
  // to a configuration with specific bids.
  BiddableAdGroupCriterion biddableCriterion = new BiddableAdGroupCriterion();
  biddableCriterion.setAdGroupId(adGroupId);
  biddableCriterion.setCriterion(criterionUserList);
  biddableCriterion.setBidModifier(1.25);

  // Create an operation to ADD the BiddableAdGroupCriterion.
  AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
  operation.setOperand(biddableCriterion);
  operation.setOperator(Operator.ADD);
  operations.add(operation);
}

// Submit the operations.
AdGroupCriterionReturnValue result = adGroupCriterionService.mutate(
    operations.toArray(new AdGroupCriterionOperation[operations.size()]));

O processo para modificar lances de uma campanha é muito semelhante:

// Specify the campaign ID.
Long campaignId = // ID of campaign

// Create a CriterionUserList that points to the user list created above.
CriterionUserList criterionUserList = new CriterionUserList();
criterionUserList.setUserListId(dateRuleUserList.getId());

CampaignCriterion campaignCriterion = new CampaignCriterion();
campaignCriterion.setCampaignId(campaignId);
campaignCriterion.setCriterion(criterionUserList);
campaignCriterion.setBidModifier(1.25);

CampaignCriterionOperation operation = new CampaignCriterionOperation();
operation.setOperand(campaignCriterion);
operation.setOperator(Operator.ADD);
operations.add(operation);

// Submit the operations.
CampaignCriterionReturnValue result = CampaignCriterionService.mutate(
    new AdGroupCriterionOperation[] {operation});

Opções de lista de usuário adicionais

É possível ir um passo adiante com suas listas de usuários com base em regras e combiná-las a outras listas de usuários para criar uma segmentação ainda mais sofisticada. Por exemplo, se você tiver um BasicUserList que segmenta um tipo de conversão específico e um RuleBasedUserList que segmenta usuários com base em parâmetros personalizados, poderá segmentar membros das duas listas criando um LogicalUserList. Veja listas múltiplas de usuários acima como exemplo.

Adicionar a tag de remarketing ao site

Para preencher suas listas de usuários com base em regras, é necessário adicionar a tag de remarketing no nível da conta ao seu site. Siga as instruções acima para recuperar a tag e instalá-la no seu site.

Se você estiver usando somente parâmetros integrados da tag de remarketing, não é necessário fazer edições na sua tag de remarketing. Se você estiver usando parâmetros personalizados, consulte o artigo a seguir para saber como editar sua tag para incluí-los: Estratégias avançadas para codificar e criar de listas de remarketing.

Exemplos de código

Para ver exemplos de código completos para adicionar uma lista de usuários com base em regras, consulte a pasta Remarketing de cada biblioteca cliente:

Enviar comentários sobre…

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