Palavras-chave negativas em conflito e conjuntos compartilhados

As palavras-chave negativas evitam a exibição de anúncios nos resultados de pesquisa irrelevantes. No entanto, o uso de um tipo de correspondência incorreto na sua lista de palavras-chave negativas pode bloquear a correspondência de palavra-chave normal, ainda que sem essa intenção, reduzindo a eficácia da sua campanha.

Este guia explica como automatizar a eliminação de palavras-chave negativas em conflito usando a AdWords API. Ele também descreve o uso de conjuntos compartilhados para gerenciar palavras-chave negativas e canais.

Cenário

Digamos que você tenha uma loja de roupas masculinas e queira aumentar o tráfego para o seu site veiculando uma campanha de inverno especial para acessórios masculinos. Recentemente, você gerou um Relatório de termos de pesquisa e percebeu que os anúncios da sua campanha para acessórios masculinos também estão sendo exibidos quando os usuários pesquisam cachecóis de seda femininos.

Você usa palavras-chave de correspondência ampla como "gravatas de seda", "cachecóis de lã" e "presentes para homens" na sua lista de palavras-chave. Você deseja adicionar "cachecóis de seda" como uma palavra-chave negativa, mas qual tipo de correspondência de palavra-chave negativa você deve escolher?

A tabela abaixo lista alguns termos de pesquisa e indica se um anúncio será bloqueado, considerando cada um dos três tipos de correspondência negativa.

Termo de pesquisa Palavra-chave negativa
–cachecóis de seda
(negativa ampla)
–"cachecóis de seda"
(frase negativa)
–[cachecóis de seda]
(exata negativa)
cachecóis para homens
gravatas masculinas
seda cachecóis Sinal de proibido
gravatas de seda
cachecóis presente seda Sinal de proibido
cachecóis de seda Sinal de proibido Sinal de proibido Sinal de proibido
cachecóis de seda presentes Sinal de proibido Sinal de proibido
gravatas de seda cachecóis de lã Sinal de proibido
cachecóis de seda para mulheres Sinal de proibido Sinal de proibido
cachecóis de lã

Observe como a palavra-chave negativa de correspondência ampla –cachecóis de seda bloqueia termos de pesquisa válidos como "gravatas de seda cachecóis de lã".

Como identificar palavras-chave negativas em conflito em escala

É fácil determinar quais palavras-chave negativas entram em conflito com as palavras-chave positivas se você usa apenas algumas. No entanto, torna-se muito mais difícil se você tem milhares de palavras-chave e centenas de palavras-chave negativas na sua conta. Vamos entender como automatizar esse processo usando a AdWords API.

Para facilitar a demonstração, restringiremos o cenário ao uso de palavras-chave positivas no nível do grupo de anúncios e palavras-chave negativas no nível da campanha.

Como recuperar palavras-chave negativas

Para recuperar a lista de palavras-chave negativas no nível da campanha, execute um Relatório de desempenho das palavras-chave negativas da campanha do seguinte modo:

def retrieve_negative_keywords(report_utils)
  report_definition = {
    :selector => {
      :fields => ['CampaignId', 'Id', 'KeywordMatchType', 'KeywordText']
    },
    :report_name => 'Negative campaign keywords',
    :report_type => 'CAMPAIGN_NEGATIVE_KEYWORDS_PERFORMANCE_REPORT',
    :download_format => 'CSV',
    :date_range_type => 'TODAY',
    :include_zero_impressions => true
  }

  campaigns = {}

  report = report_utils.download_report(report_definition)
  # Slice off the first row (report name).
  report.slice!(0..report.index("\n"))

  CSV.parse(report, { :headers => true }) do |row|
    campaign_id = row['Campaign ID']

    # Ignore totals row.
    if row[0] != 'Total'
      campaigns[campaign_id] ||= Campaign.new(campaign_id)
      negative = Negative.from_csv_row(row)
      campaigns[campaign_id].negatives << negative
    end
  end

  return campaigns
end

Como recuperar palavras-chave positivas

Execute um Relatório de desempenho de palavras-chave para recuperar a lista de palavras-chave positivas. O parâmetro allowed_values permite filtrar campanhas, grupos de anúncios e palavras-chave por status, além de aceitar os valores PAUSED e REMOVED.

def retrieve_positive_keyword_report(report_utils, allowed_values)
  report_definition = {
    :selector => {
      :fields => ['CampaignId', 'CampaignName', 'AdGroupId', 'Id',
                  'KeywordMatchType', 'KeywordText'],
      :predicates => [
        {
          :field => 'CampaignStatus',
          :operator => 'IN',
          :values => allowed_values
        },
        {
          :field => 'AdGroupStatus',
          :operator => 'IN',
          :values => allowed_values
        },
        {
          :field => 'Status',
          :operator => 'IN',
          :values => allowed_values
        },
        {
          :field => 'IsNegative',
          :operator => 'IN',
          :values => ['false']
        }
      ]
    },
    :report_name => 'Ad group keywords',
    :report_type => 'KEYWORDS_PERFORMANCE_REPORT',
    :download_format => 'CSV',
    :date_range_type => 'TODAY',
    :include_zero_impressions => true
  }

  report = report_utils.download_report(report_definition)
  # Slice off the first row (report name).
  report.slice!(0..report.index("\n"))

  return report
end

Como identificar palavras-chave negativas em conflito

As palavras-chave negativas funcionam de acordo com a seguinte lógica:

  • Uma palavra-chave negativa ampla bloqueia um termo de pesquisa se ele contiver TODAS as palavras da palavra-chave negativa. Por exemplo, –cachecóis de seda bloqueia "cachecóis de seda para presente", mas não "cachecóis de lã".
  • Uma palavra-chave negativa de frase bloqueia um termo de pesquisa se ele contiver todas as palavras da palavra-chave negativa como uma única frase. Por exemplo, –"cachecóis de seda" bloqueia "cachecóis de seda para presente", mas não "cachecóis presente seda".
  • Uma palavra-chave negativa exata bloqueia um termo de pesquisa se ele corresponder exatamente ao termo de pesquisa. Por exemplo, –[cachecóis de seda] bloqueia "cachecóis de seda", mas não "cachecóis de seda vermelhos".
  • As palavras-chave não diferenciam maiúsculas de minúsculas.
  • Correspondências de variantes próximas não se aplicam às palavras-chave negativas. Por exemplo, –cachecóis de seda não bloqueia "cachecol de seda", embora essa palavra-chave seja uma correspondência de variante próxima de "cachecóis de seda".

O método a seguir implementa essa lógica:

def compare_keywords(negatives, positive)
  negatives.each do |negative|
    match_type = negative.match_type.downcase
    negative_text = negative.text.downcase
    positive_text = positive.text.downcase

    match = false

    # Exact matching with negative keywords triggers only when the full text of
    # the keywords is exactly the same.
    # E.g. a negative "silk scarves" will only match "silk scarves", not
    # "red silk scarves".
    if match_type == 'exact'
      match = (negative_text == positive_text)
    end

    # Phrase matching with negative keywords triggers when the negative phrase
    # is present in the target, completely unmodified.
    # E.g. a negative "silk scarves" will match "gift silk scarves", but not
    # "silk gift scarves".
    if match_type == 'phrase'
      negative_tokens = negative_text.split(' ')
      positive_tokens = positive_text.split(' ')

      positive_tokens.each_with_index do |positive_token, positive_index|
        # Iterate until the current token matches the first token in the
        # negative keyword.
        if positive_token == negative_tokens.first
          candidate_match = true
          # Do all of the subsequent tokens also match?
          negative_tokens[1..-1].each_with_index do |token, index|
            if token != positive_tokens[positive_index + index + 1]
              candidate_match = false
              break
            end
          end

          match = candidate_match
        end
      end
    end

    # Broad matching with negative keywords triggers when all of the words are
    # present and exactly the same.
    # E.g. a negative "silk scarves" will match "silk gift scarves", but not
    # "wool scarves".
    if match_type == 'broad'
      negative_tokens = negative_text.split(' ')
      positive_tokens = positive_text.split(' ')

      candidate_match = true

      negative_tokens.each do |token|
        if !positive_tokens.include?(token)
          candidate_match = false
          break
        end
      end

      match = candidate_match
    end

    negative.add_blocked(positive) if match
  end
end

Como excluir palavras-chave negativas em conflito

Depois de identificar as palavras-chave negativas em conflito, você pode:

  • usar o CampaignCriterionService para excluir as palavras-chave negativas em conflito;
  • gerar um relatório e excluí-las manualmente.

Você deve repetir esse processo periodicamente para garantir que alterações nas suas listas de palavras-chave ou palavras-chave negativas não causaram novos conflitos.

Exemplo de código completo

Os exemplos de código completos usados acima são parte da biblioteca cliente Ruby da AdWords API.

Conjuntos compartilhados

Se você tem um conjunto de palavras-chave ou canais que fornece impressões ou cliques indesejados em várias campanhas, é possível criar uma lista central dessas palavras-chave negativas ou canais no Google AdWords e adicioná-la a todas as suas campanhas. Esse recurso é conhecido como conjuntos compartilhados.

Os conjuntos compartilhados ajudam a gerenciar suas palavras-chave negativas e exclusões de canais de forma mais eficiente removendo a necessidade de duplicação de entidades na sua conta.

Esta seção explica como usar a AdWords API para criar e trabalhar com conjuntos compartilhados.

Os exemplos de código usam a biblioteca Java da AdWords API. Também disponibilizamos exemplos de código para outras bibliotecas cliente compatíveis.

Como criar conjuntos compartilhados

Para usar um conjunto compartilhado de palavras-chave negativas, primeiro você precisa criar um conjunto compartilhado e, em seguida, preenchê-lo com a lista de palavras-chave que você deseja excluir. O snippet de código a seguir cria um conjunto compartilhado de palavras-chave negativas usando o SharedSetService.


// Create the operation.
SharedSetOperation operation = new SharedSetOperation();
operation.setOperator(Operator.ADD);

// Create the shared set.
SharedSet sharedSet = new SharedSet();
sharedSet.setName("API Negative keyword list for demo");

// Set the type of the shared set. This may be negative keywords or placements.
sharedSet.setType(SharedSetType.NEGATIVE_KEYWORDS);
operation.setOperand(sharedSet);

SharedSetReturnValue retval = sharedSetService.mutate(
    new SharedSetOperation[] {operation});
for (SharedSet set : retval.getValue()) {
  System.out.println("Shared set with id = " + set.getSharedSetId() + ", name = " +
      set.getName() + ", type = " + set.getType() + ", status = " + set.getStatus() +
      "was created.");
}

Depois de criar o conjunto compartilhado, é possível usar o SharedCriterionService para adicionar palavras-chave ao conjunto recém-criado. O snippet de código a seguir adiciona duas novas palavras-chave ao conjunto compartilhado.

String[] keywordTexts = new String[] {"mars cruise", "mars hotels"};

List operations = new ArrayList();
for (String keywordText: keywordTexts) {
  // Create the shared criterion.
  Keyword keyword = new Keyword();
  keyword.setText(keywordText);
  keyword.setMatchType(KeywordMatchType.BROAD);

  SharedCriterion sharedCriterion = new SharedCriterion();
  sharedCriterion.setCriterion(keyword);
  sharedCriterion.setNegative(true);
  sharedCriterion.setSharedSetId(sharedSetId);

  SharedCriterionOperation operation = new SharedCriterionOperation();
  operation.setOperator(Operator.ADD);
  operation.setOperand(sharedCriterion);
  operations.add(operation);
}

SharedCriterionReturnValue retval = sharedCriterionService.mutate(operations.toArray(
    new SharedCriterionOperation[operations.size()]));
for (SharedCriterion sharedCriterion : retval.getValue()) {
  Keyword keyword = (Keyword) sharedCriterion.getCriterion();
  System.out.println("Added keyword with id = " + keyword.getId() + ", text = " +
      keyword.getText() + ", matchtype = " + keyword.getMatchType() + " to shared " +
      "set with id = " + sharedSetId + ".");
}

Você pode usar o campo memberCount para determinar o número de palavras-chave ou canais em um conjunto compartilhado. Outro campo útil é referenceCount, que informa a quantas campanhas um conjunto compartilhado está associado.

Como aplicar conjuntos compartilhados em uma campanha

Depois de criar um conjunto compartilhado, você pode vinculá-lo a várias campanhas usando CampaignSharedSetService. O código a seguir mostra como vincular um conjunto compartilhado existente a uma campanha:

// Create the campaign shared set
CampaignSharedSet campaignSharedSet = new CampaignSharedSet();
campaignSharedSet.setCampaignId(campaignId);
campaignSharedSet.setSharedSetId(sharedSetId);

CampaignSharedSetOperation operation = new CampaignSharedSetOperation();
operation.setOperator(Operator.ADD);
operation.setOperand(campaignSharedSet);

CampaignSharedSetReturnValue retval = campaignSharedSetService.mutate(
    new CampaignSharedSetOperation[] {operation});
for (CampaignSharedSet attachedCampaignSharedSet : retval.value) {
  System.out.println("Attached shared set with id = " +
      attachedCampaignSharedSet.getSharedSetId() + " to campaign id " +
      attachedCampaignSharedSet.getCampaignId() + ".");
}

É possível usar o método CampaignSharedSetService.get() para recuperar os conjuntos compartilhados que foram aplicados a uma campanha existente, como mostrado abaixo.

// Create the selector.
Selector selector = new Selector();
selector.setFields(new String[] {"SharedSetId", "CampaignId", "SharedSetName",
   "SharedSetType", "Status"});

// Filter your results by specific campaign id.
Predicate predicate = new Predicate();
predicate.setField("CampaignId");
predicate.setOperator(PredicateOperator.EQUALS);
predicate.setValues(new String[] {campaignId.toString()});

// Filter your results by the type of shared set.
Predicate predicate1 = new Predicate();
predicate1.setField("SharedSetType");
predicate1.setOperator(PredicateOperator.IN);
predicate1.setValues(new String[] {"NEGATIVE_KEYWORDS", "NEGATIVE_PLACEMENTS"});

selector.setPredicates(new Predicate[] {predicate});

CampaignSharedSetPage page = campaignSharedSetService.get(selector);
if (page.getEntries() != null) {
  for (CampaignSharedSet campaignSharedSet : page.getEntries()) {
    System.out.println("Shared set with id = " + campaignSharedSet.getSharedSetId() +
        ", name = " + campaignSharedSet.getSharedSetName() + ", type = " +
        campaignSharedSet.getSharedSetType() + " and status = " +
        campaignSharedSet.getStatus() + " was found.");
    }
  }
}

Relatórios

Use o relatório Conjunto compartilhado para recuperar dados de relatórios sobre conjuntos compartilhados. Use o relatório Conjunto compartilhado de campanhas para recuperar dados de relatórios sobre conjuntos compartilhados de campanhas. O relatório Critérios do conjunto compartilhado fornece um resumo dos critérios do conjunto compartilhado disponível para download.

Enviar comentários sobre…

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