Palavras-chave e canais negativos e conjuntos compartilhados

As palavras-chave negativas evitam a exibição de anúncios em 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 normal de palavras-chave, ainda que de forma não intencional, o que reduz a eficácia da sua campanha.

Os canais negativos impedem a exibição de anúncios ao lado de determinados tipos de conteúdo ou em sites, aplicativos para dispositivos móveis, vídeos ou canais do YouTube específicos na Rede de Display.

Neste guia, você aprenderá a:

  • automatizar a remoção de palavras-chave negativas conflitantes usando a Google AdWords API;
  • usar conjuntos compartilhados para gerenciar palavras-chave e canais negativos;
  • usar critérios negativos do cliente para excluir canais específicos em todas as campanhas da sua conta.

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
-silk scarves
(negativa ampla)
-"silk scarves"
(frase negativa)
-[silk scarves]
(negativa exata)
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

Gere um Relatório de desempenho por palavra-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 mais restritiva que o termo de pesquisa não bloqueia esse termo. Por exemplo, -[silk scarves] não bloqueará "lenços de seda vermelha".
  • Uma palavra-chave negativa ampla bloqueia um termo de pesquisa se ele contiver TODOS os vocábulos 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

    # If the negative keyword is more strict than the positive one, it cannot
    # match.
    # E.g. a negative exact "cool shoe" will not prevent positive phrase
    # "cool shoe shine".
    positive_match_type = positive.match_type.downcase
    next if positive_match_type == 'broad' && match_type != 'broad'
    next if positive_match_type == 'phrase' && match_type == 'exact'

    # 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 fazem parte da biblioteca de cliente Ruby da Google AdWords API.

Conjuntos compartilhados

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

Os conjuntos compartilhados ajudam a gerenciar as exclusões de palavras-chave e de canais negativos de forma mais eficiente, eliminando as cópias de entidades na sua conta.

Na versão 201710, foi adicionado o suporte para a criação de conjuntos compartilhados nas contas de administrador. Se você usar uma versão anterior da Google AdWords API, poderá criar um conjunto compartilhado na sua conta de administrador por meio da IU e gerenciar os critérios e associações de campanha dela usando a API.

Tipo de conjunto compartilhado Tipo de conta SharedSetService SharedCriterionService CampaignSharedSetService
Palavras-chave negativas Cliente Marca de seleção Marca de seleção Marca de seleção
Palavras-chave negativas Administrador A partir da v201710 Marca de seleção Marca de seleção
Canais negativos Cliente Marca de seleção Marca de seleção Marca de seleção
Canais negativos Administrador Sinal de proibido Sinal de proibido Sinal de proibido

Nesta seção, explicamos como usar a Google AdWords API para criar e trabalhar com conjuntos compartilhados. O exemplo se concentra nas palavras-chave negativas. Você pode criar conjuntos compartilhados de canais negativos para contas de clientes que usam uma abordagem semelhante.

Os exemplos de código usam a biblioteca Java da Google 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 gostaria de 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 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 de critérios do conjunto compartilhado oferece um resumo dos critérios do conjunto compartilhado e está disponível para download.

Critérios negativos no nível da conta

A partir da v201710 da Google AdWords API, você pode usar o CustomerNegativeCriterionService para excluir critérios específicos da Rede de Display em todas as campanhas da sua conta de cliente.

O serviço aceita os seguintes tipos de critérios negativos:

A adição de critérios de exclusão no nível da conta é semelhante aos serviços do conjunto compartilhado. As principais diferenças são as seguintes:

  • Os critérios criados por meio do CustomerNegativeCriterionService se aplicam a todas as campanhas da sua conta. Ao usar a abordagem do conjunto compartilhado, os critérios serão excluídos somente nas campanhas associadas ao conjunto.

  • A exclusão de um critério no nível da conta é um processo de uma única etapa: basta adicionar o CustomerNegativeCriterion. Por outro lado, excluir um critério de campanhas específicas usando conjuntos compartilhados envolve várias etapas: criar o conjunto compartilhado, adicionar os critérios a ele e associá-lo a uma ou mais campanhas.

O snippet de código a seguir mostra como evitar que todos os anúncios da sua conta apareçam ao lado de determinados tipos de conteúdo ou em um site específico:

Java

// Get the CustomerNegativeCriterionService.
CustomerNegativeCriterionServiceInterface customerNegativeCriterionService =
    adWordsServices.get(session, CustomerNegativeCriterionServiceInterface.class);

List<Criterion> criteria = new ArrayList<>();

// Exclude tragedy & conflict content.
ContentLabel tragedyContentLabel = new ContentLabel();
tragedyContentLabel.setContentLabelType(ContentLabelType.TRAGEDY);
criteria.add(tragedyContentLabel);

// Exclude a specific placement.
Placement placement = new Placement();
placement.setUrl("http://www.example.com");
criteria.add(placement);

// Additional criteria types are available for this service. See the types listed
// under Criterion here:
// https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion

// Create operations to add each of the criteria above.
List<CustomerNegativeCriterionOperation> operations = new ArrayList<>();
for (Criterion criterion : criteria) {
  CustomerNegativeCriterion negativeCriterion = new CustomerNegativeCriterion();
  negativeCriterion.setCriterion(criterion);
  CustomerNegativeCriterionOperation operation = new CustomerNegativeCriterionOperation();
  operation.setOperator(Operator.ADD);
  operation.setOperand(negativeCriterion);
  operations.add(operation);
}

// Send the request to add the criteria.
CustomerNegativeCriterionReturnValue result =
    customerNegativeCriterionService.mutate(
        operations.toArray(new CustomerNegativeCriterionOperation[operations.size()]));

// Display the results.
for (CustomerNegativeCriterion negativeCriterion : result.getValue()) {
  System.out.printf(
      "Customer negative criterion with criterion ID %d and type '%s' was added.%n",
      negativeCriterion.getCriterion().getId(),
      negativeCriterion.getCriterion().getCriterionType());
}

CSharp

using (CustomerNegativeCriterionService customerNegativeCriterionService =
    (CustomerNegativeCriterionService) user.GetService(
        AdWordsService.v201802.CustomerNegativeCriterionService)) {

  List<Criterion> criteria = new List<Criterion>();

  // Exclude tragedy & conflict content.
  ContentLabel tragedyContentLabel = new ContentLabel();
  tragedyContentLabel.contentLabelType = ContentLabelType.TRAGEDY;
  criteria.Add(tragedyContentLabel);

  // Exclude a specific placement.
  Placement placement = new Placement();
  placement.url = "http://www.example.com";
  criteria.Add(placement);

  // Additional criteria types are available for this service. See the types listed
  // under Criterion here:
  // https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion

  // Create operations to add each of the criteria above.
  List<CustomerNegativeCriterionOperation> operations =
      new List<CustomerNegativeCriterionOperation>();
  foreach (Criterion criterion in criteria) {
    CustomerNegativeCriterion negativeCriterion = new CustomerNegativeCriterion();
    negativeCriterion.criterion = criterion;
    CustomerNegativeCriterionOperation operation = new CustomerNegativeCriterionOperation();
    operation.@operator = Operator.ADD;
    operation.operand = negativeCriterion;
    operations.Add(operation);
  }

  try {
    // Send the request to add the criteria.
    CustomerNegativeCriterionReturnValue result =
        customerNegativeCriterionService.mutate(operations.ToArray());

    // Display the results.
    foreach (CustomerNegativeCriterion negativeCriterion in result.value) {
      Console.WriteLine("Customer negative criterion with criterion ID {0} and type '{1}' " +
          "was added.", negativeCriterion.criterion.id,
          negativeCriterion.criterion.type);
    }
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to set customer negative criteria.", e);
  }
}

Python

customer_negative_criterion_service = client.GetService(
    'CustomerNegativeCriterionService', version='v201802')

criteria = [
    # Exclude tragedy & conflict content.
    {
        'xsi_type': 'ContentLabel',
        'contentLabelType': 'TRAGEDY'
    },
    # Exclude a specific placement.
    {
        'xsi_type': 'Placement',
        'url': 'http://www.example.com'
    }
    # Additional criteria types are available for this service. See the types
    # listed under Criterion here:
    # https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion
]

# Create operations to add each of the criteria above.
operations = [{
    'operator': 'ADD',
    'operand': {
        'criterion': criterion
    }
} for criterion in criteria]

# Make the mutate request.
result = customer_negative_criterion_service.mutate(operations)

# Display the resulting campaign criteria.
for negative_criterion in result['value']:
  print ('Customer negative criterion with criterion ID "%s", and type "%s" '
         'was added.' % (negative_criterion['criterion']['id'],
                         negative_criterion['criterion']['type']))

PHP

$customerNegativeCriterionService = $adWordsServices->get(
    $session,
    CustomerNegativeCriterionService::class
);

$criteria = [];

// Exclude tragedy & conflict content.
$tragedyContentLabel = new ContentLabel();
$tragedyContentLabel->setContentLabelType(ContentLabelType::TRAGEDY);
$criteria[] = $tragedyContentLabel;

// Exclude a specific placement.
$placement = new Placement();
$placement->setUrl('http://www.example.com');
$criteria[] = $placement;

// Additional criteria types are available for this service. See the types
// listed under Criterion here:
// https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion

// Create operations to add each of the criteria above.
$operations = [];
foreach ($criteria as $criterion) {
    $negativeCriterion = new CustomerNegativeCriterion();
    $negativeCriterion->setCriterion($criterion);
    $operation = new CustomerNegativeCriterionOperation();
    $operation->setOperator(Operator::ADD);
    $operation->setOperand($negativeCriterion);
    $operations[] = $operation;
}

// Add the criteria on the server and print out some information.
$result = $customerNegativeCriterionService->mutate($operations);
foreach ($result->getValue() as $negativeCriterion) {
    printf(
        "Customer negative criterion with criterion ID %d and type '%s' was added.\n",
        $negativeCriterion->getCriterion()->getId(),
        $negativeCriterion->getCriterion()->getType()
    );
}

Perl

# Get the CustomerNegativeCriterionService.
my @criteria = ();

# Exclude tragedy & conflict content.
my $tragedy_content_label = Google::Ads::AdWords::v201802::ContentLabel->new({
  contentLabelType => 'TRAGEDY'
});
push @criteria, $tragedy_content_label;

# Exclude a specific placement.
my $placement = Google::Ads::AdWords::v201802::Placement->new({
  url => 'http://www.example.com'
});
push @criteria, $placement;

# Additional criteria types are available for this service. See the types
# listed under Criterion here:
# https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion

# Create operations to add each of the criteria above.
my @operations = ();
for my $criterion (@criteria) {
  my $negative_criterion =
    Google::Ads::AdWords::v201802::CustomerNegativeCriterion->new({
      criterion => $criterion
    });
  my $operation =
    Google::Ads::AdWords::v201802::CustomerNegativeCriterionOperation->new({
      operator => 'ADD',
      operand  => $negative_criterion
    });
  push @operations, $operation;
}

# Send the request to add the criteria.
my $result =
  $client->CustomerNegativeCriterionService()
  ->mutate({operations => \@operations});

# Display the results.
if ($result->get_value()) {
  foreach my $negative_criterion (@{$result->get_value()}) {
    printf "Campaign negative criterion with criterion ID %d and type " .
      "'%s' was added.\n",
      $negative_criterion->get_criterion()->get_id(),
      $negative_criterion->get_criterion()->get_type();
  }
}

Ruby

customer_negative_criterion_srv = adwords.service(
    :CustomerNegativeCriterionService, API_VERSION)

criteria = []

# Exclude tragedy & conflict content.
criteria << {
  :xsi_type => 'ContentLabel',
  :content_label_type => 'TRAGEDY'
}

# Exclude a specific placement.
criteria << {
  :xsi_type => 'Placement',
  :url => 'http://www.example.com'
}

# Additional criteria types are available for this service. See the types
# listed under Criterion here:
# https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion

# Create operations to add each of the criteria above.
operations = criteria.map do |criterion|
  {
    :operator => 'ADD',
    :operand => {
      :criterion => criterion
    }
  }
end

# Send the request to add the criteria.
result = customer_negative_criterion_srv.mutate(operations)

# Display the results.
result[:value].each do |negative_criterion|
  puts ("Customer negative criterion with criterion ID %d and type '%s' " +
      "was added.") % [negative_criterion[:criterion][:id],
      negative_criterion[:criterion][:criterion_type]]
end

VB.NET

Using customerNegativeCriterionService As CustomerNegativeCriterionService =
    CType(user.GetService(AdWordsService.v201802.CustomerNegativeCriterionService),
        CustomerNegativeCriterionService)

  Dim criteria As New List(Of Criterion)

  ' Exclude tragedy & conflict content.
  Dim tragedyContentLabel As New ContentLabel()
  tragedyContentLabel.contentLabelType = ContentLabelType.TRAGEDY
  criteria.Add(tragedyContentLabel)

  ' Exclude a specific placement.
  Dim placement As New Placement()
  placement.url = "http://www.example.com"
  criteria.Add(placement)

  ' Additional criteria types are available for this service. See the types listed
  ' under Criterion here:
  ' https://developers.google.com/adwords/api/docs/reference/latest/CustomerNegativeCriterionService.Criterion

  ' Create operations to add each of the criteria above.
  Dim operations As New List(Of CustomerNegativeCriterionOperation)
  For Each criterion As Criterion In criteria
    Dim negativeCriterion As New CustomerNegativeCriterion()
    negativeCriterion.criterion = criterion
    Dim operation As New CustomerNegativeCriterionOperation()
    operation.operator = [Operator].ADD
    operation.operand = negativeCriterion
    operations.Add(operation)
  Next

  Try
    ' Send the request to add the criteria.
    Dim result As CustomerNegativeCriterionReturnValue =
        customerNegativeCriterionService.mutate(operations.ToArray())

    ' Display the results.
    For Each negativeCriterion As CustomerNegativeCriterion In result.value
      Console.WriteLine("Customer negative criterion with criterion ID {0} and type '{1}' " +
          "was added.", negativeCriterion.criterion.id,
          negativeCriterion.criterion.type)
    Next
  Catch e As Exception
    Throw New System.ApplicationException("Failed to set customer negative criteria.", e)
  End Try

End Using

Exemplo de código completo

Enviar comentários sobre…

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