Auszuschließende Keywords und Placements sowie freigegebene Sätze

Mit auszuschließenden Keywords wird verhindert, dass Anzeigen bei irrelevanten Suchergebnissen ausgeliefert werden. Enthält die Liste mit auszuschließenden Keywords jedoch eine falsche Keyword-Option, kann dies versehentlich die normalen Keywords-Optionen blockieren. Die Effizienz Ihrer Kampagne nimmt dann ab.

Mit auszuschließenden Placements können Sie verhindern, dass Anzeigen zusammen mit bestimmten Arten von Inhalten oder auf bzw. in festgelegten Websites, mobilen Apps, YouTube-Videos oder YouTube-Kanälen im Displaynetzwerk ausgeliefert werden.

In diesem Leitfaden wird Folgendes beschrieben:

  • Wie die Beseitigung widersprüchlicher auszuschließender Keywords mithilfe der AdWords API automatisiert werden kann
  • Wie freigegebene Sätze zur Verwaltung auszuschließender Keywords und Placements verwendet werden können
  • Wie auszuschließende Kundenkriterien genutzt werden können, um bestimmte Placements in allen Kampagnen in Ihrem Konto zu blockieren

Szenario

Angenommen, Sie besitzen ein Bekleidungsgeschäft für Männer und möchten die Zugriffe auf Ihre Website steigern, indem Sie eine spezielle Winterurlaubskampagne für Herrenaccessoires schalten. Sie haben kürzlich in einem Bericht zu Suchbegriffen gesehen, dass die Anzeigen in Ihrer Kampagne für Herrenaccessoires auch dann ausgeliefert werden, wenn Nutzer nach Seidenschals für Frauen suchen.

In Ihrer Keywords-Liste befinden sich die weitgehend passenden Keywords "seide krawatten", "wolle schals" und "geschenke für männer". Sie möchten "seide schals" als auszuschließendes Keyword hinzufügen. Welche auszuschließende Keyword-Option sollten Sie verwenden?

Die Tabelle unten führt einige Suchbegriffe auf und gibt für jede der drei auszuschließenden Keyword-Optionen an, ob eine Anzeige blockiert wird.

Suchbegriff Auszuschließendes Keyword
-silk scarves
(auszuschließen, weitgehend passend)
-"silk scarves"
(auszuschließende Wortgruppe)
-[silk scarves]
(auszuschließen, genau passend)
herren schals
herren krawatten
schals seide Kreis mit Schrägstrich
seide krawatten
seide geschenk schals Kreis mit Schrägstrich
seide schals Kreis mit Schrägstrich Kreis mit Schrägstrich Kreis mit Schrägstrich
seide schals geschenke Kreis mit Schrägstrich Kreis mit Schrägstrich
seide krawatten wolle schals Kreis mit Schrägstrich
frauen seide schals Kreis mit Schrägstrich Kreis mit Schrägstrich
wolle schals

Sie sehen, wie das weitgehend passende auszuschließende Keyword -seide schals einige gültige Suchbegriffe wie "seide krawatten wolle schals" blockiert.

Widersprüchliche auszuschließende Keywords in großen Mengen identifizieren

Es kann einfach festgestellt werden, welche auszuschließenden Keywords im Widerspruch zu einzuschließenden Keywords stehen, wenn Sie nur wenige Keywords verwenden. Erheblich schwieriger wird es, wenn es Tausende von Keywords und Hunderte von auszuschließenden Keywords in Ihrem Konto gibt. Im Folgenden erfahren Sie, wie dieser Vorgang mithilfe der AdWords API automatisiert werden kann.

Um die Sache zu erleichtern, beschränken wir das Szenario auf einzuschließende Keywords auf der Anzeigengruppenebene und auszuschließende Keywords auf der Kampagnenebene.

Auszuschließende Keywords abrufen

Sie rufen die Liste der auszuschließenden Keywords auf Kampagnenebene ab, indem Sie einen Leistungsbericht zu auszuschließenden Keywords der Kampagne erstellen:

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

Einzuschließende Keywords abrufen

Wenn Sie die Liste mit einzuschließenden Keywords abrufen möchten, generieren Sie einen Keywords-Leistungsbericht. Mit dem Filter allowed_values können Sie Kampagnen, Anzeigengruppen und Keywords nach ihrem Status filtern. Er akzeptiert die Werte PAUSED und 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

Widersprüchliche auszuschließende Keywords identifizieren

Auszuschließende Keywords folgen dieser Logik:

  • Wenn das auszuschließende Keyword strengere Kriterien hat als der Suchbegriff, wird dieser nicht blockiert. Beispielsweise wird "rot seide schals" nicht durch -[silk scarves] blockiert.
  • Ein weitgehend passendes auszuschließendes Keyword blockiert einen Suchbegriff, wenn der Suchbegriff alle Wörter im auszuschließenden Keyword enthält. So blockiert beispielsweise -seide schals "seide geschenk schals", nicht jedoch "wolle schals".
  • Ein auszuschließendes Keyword für eine Wortgruppe blockiert einen Suchbegriff, wenn der Suchbegriff alle Wörter im auszuschließenden Keyword in einer einzelnen Wortgruppe enthält. So blockiert beispielsweise -"seide schals" "geschenk seide schals", nicht jedoch "seide geschenk schals".
  • Ein genau passendes auszuschließendes Keyword blockiert einen Suchbegriff nur dann, wenn der Suchbegriff damit genau übereinstimmt. So blockiert beispielsweise -[seide schals] "seide schals", nicht jedoch "rot seide schals".
  • In Keywords wird die Groß-/Kleinschreibung nicht beachtet.
  • Sehr ähnliche Keyword-Varianten gelten für auszuschließende Keywords nicht. So blockiert beispielsweise -seide schals "seide schal" nicht, obwohl dieses Keyword dem Keyword "seide schals" sehr ähnlich ist.

Mit der folgenden Methode wird diese Logik implementiert:

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

Widersprüchliche auszuschließende Keywords löschen

Nachdem Sie die widersprüchlichen auszuschließenden Keywords identifiziert haben, gibt es zwei Möglichkeiten:

  • Löschen Sie die widersprüchlichen auszuschließenden Keywords mit CampaignCriterionService.
  • Generieren Sie einen Bericht und löschen Sie sie manuell.

Sie sollten diesen Vorgang in regelmäßigen Abständen wiederholen, um sicherzustellen, dass Änderungen an Ihren Listen mit Keywords oder auszuschließenden Keywords nicht neue Konflikte verursacht haben.

Vollständiges Codebeispiel

Die oben verwendeten vollständigen Codebeispiele gehören zur AdWords API-Ruby-Clientbibliothek.

Freigegebene Sätze

Wenn Sie einen Satz von Keywords oder Placements verwenden, mit dem in mehreren Kampagnen unerwünschte Impressionen oder Klicks generiert werden, können Sie in AdWords eine gemeinsame Liste dieser auszuschließenden Keywords oder Placements erstellen und allen Kampagnen hinzufügen. Diese Funktion wird als freigegebene Sätze bezeichnet.

Mit freigegebenen Sätzen können Sie auszuschließende Keywords und Placement-Ausschlüsse effizienter verwalten, weil Sie Entitäten nicht mehr innerhalb des Kontos mehrfach festlegen müssen.

Das Erstellen freigegebener Sätze in Verwaltungskonten wird seit Version 201710 unterstützt. Falls Sie eine frühere Version der AdWords API nutzen, können Sie in Ihrem Verwaltungskonto auf der Benutzeroberfläche einen freigegebenen Satz erstellen. Anschließend haben Sie die Möglichkeit, die Kriterien und Kampagnenverknüpfungen dieses Satzes mithilfe der AdWords API zu verwalten.

Typ des freigegebenen Satzes Kontotyp SharedSetService SharedCriterionService CampaignSharedSetService
Auszuschließende Keywords Kunde Häkchen Häkchen Häkchen
Auszuschließende Keywords Manager Ab Version 201710 Häkchen Häkchen
Auszuschließende Placements Kunde Häkchen Häkchen Häkchen
Auszuschließende Placements Manager Kreis mit Schrägstrich Kreis mit Schrägstrich Kreis mit Schrägstrich

In diesem Abschnitt wird erläutert, wie Sie mit der AdWords API freigegebene Sätze erstellen und bearbeiten. Beim Beispiel liegt der Schwerpunkt auf auszuschließenden Keywords. Sie können mithilfe einer ähnlichen Methode freigegebene Sätze auszuschließender Placements für Kundenkonten erstellen.

In den Codebeispielen wird die AdWords API-Java-Bibliothek verwendet. Es gibt aber auch Codebeispiele für andere unterstützte Clientbibliotheken.

Freigegebene Sätze erstellen

Wenn Sie einen freigegebenen Satz auszuschließender Keywords verwenden möchten, müssen Sie den freigegebenen Satz (SharedSet) erstellen und diesem dann die Keywords hinzufügen, die Sie ausschließen möchten.

Mit dem folgenden Code-Snippet wird mithilfe von SharedSetService ein freigegebener Satz auszuschließender Keywords erstellt:


// 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.");
}

Nachdem Sie den freigegebenen Satz erstellt haben, können Sie ihm mit SharedCriterionService Keywords hinzufügen. Mit dem folgenden Code-Snippet werden dem freigegebenen Satz zwei neue Keywords hinzugefügt:

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 + ".");
}

Mit dem Feld memberCount können Sie die Anzahl der Keywords oder Placements in einem freigegebenen Satz ermitteln. Ein weiteres nützliches Feld ist referenceCount. Es gibt an, mit wie vielen Kampagnen ein freigegebener Satz verknüpft ist.

Freigegebene Sätze auf eine Kampagne anwenden

Nachdem Sie einen freigegebenen Satz erstellt haben, können Sie ihn mit CampaignSharedSetService auf mehrere Kampagnen anwenden. Im folgenden Codebeispiel wird dies anhand eines vorhandenen freigegebenen Satzes gezeigt:

// 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() + ".");
}

Mit der Methode CampaignSharedSetService.get() können Sie die freigegebenen Sätze abrufen, die auf eine vorhandene Kampagne angewendet wurden:

// 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.");
    }
  }
}

Berichte

Daten für freigegebene Sätze können Sie mit dem Bericht zu freigegebenen Sätzen abrufen. Mit dem Kampagnenbericht zu freigegebenen Sätzen können Sie Daten für freigegebene Sätze auf Kampagnenebene abrufen. Der Bericht zu Kriterien für freigegebenen Satz enthält eine Übersicht der Kriterien für einen freigegebenen Satz, die Sie herunterladen können.

Ausschlusskriterien auf Kontoebene

Ab Version 201710 der AdWords API können Sie mithilfe von CustomerNegativeCriterionService bestimmte Displaynetzwerk-Kriterien in allen Kampagnen in Ihrem Kundenkonto ausschließen.

Die folgenden Arten von Ausschlusskriterien werden vom Dienst unterstützt:

Das Hinzufügen von Ausschlusskriterien auf Kontoebene ist den Diensten für freigegebene Sätze ähnlich. Es gibt jedoch die folgenden wichtigen Unterschiede:

  • Mit CustomerNegativeCriterionService erstellte Kriterien gelten für alle Kampagnen in Ihrem Konto. Bei einem freigegebenen Satz werden die Kriterien nur in den Kampagnen ausgeschlossen, die mit dem Satz verknüpft sind.

  • Sie können ein Kriterium mit einem einzigen Schritt auf Kontoebene ausschließen. Fügen Sie hierzu einfach CustomerNegativeCriterion hinzu. Zum Ausschließen eines Kriteriums aus bestimmten Kampagnen mithilfe eines freigegebenen Satzes sind hingegen mehrere Schritte erforderlich: Sie erstellen den freigegebenen Satz, fügen diesem dann Kriterien hinzu und verknüpfen ihn schließlich mit einer oder mehreren Kampagnen.

Im folgenden Code-Snippet sehen Sie, wie Sie für alle Anzeigen in Ihrem Konto verhindern können, dass diese zusammen mit bestimmten Arten von Inhalten oder auf einer unerwünschten Website erscheinen:

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());
}

C Sharp

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

Vollständiges Codebeispiel

Feedback geben zu...