Remarketing und Ausrichtung auf Zielgruppen

Mit Remarketing können Sie Nutzern, die Ihre Website bereits besucht oder Ihre mobile App verwendet haben oder in Ihren CRM-Datenbanken enthalten sind, relevante Anzeigen präsentieren, wenn sie andere Websites besuchen oder eine Suchanfrage auf Google stellen. Remarketing-Nutzerlisten lassen sich auch für andere Arten der Ausrichtung auf Zielgruppen verwenden, etwa für den Kundenabgleich.

In diesem Leitfaden werden die folgenden Themen behandelt:

Einschränkungen

  • Vertrauliche Nutzerdaten dürfen nicht zum Erstellen von Remarketing-Listen verwendet werden. Lesen Sie sich die Richtlinie für interessen- und standortbezogene Werbung durch, bevor Sie eine Remarketing-Kampagne einrichten und Ihrer Website oder App das Remarketing-Tag hinzufügen.

  • Sie können Nutzerlisten auf Anzeigengruppen- und Kampagnenebene ein- oder ausschließen. Es ist jedoch nicht möglich, gleichzeitig auf beiden Ebenen positive, gebotsfähige Nutzerlisten festzulegen. Bevor Sie ein Kriterium für positive Nutzerlisten für die Kampagne festlegen, müssen Sie die entsprechenden Kriterien aus allen Anzeigengruppen der Kampagne entfernen.

  • Die positive Ausrichtung auf der Grundlage einer Nutzerliste wird nur für Suchnetzwerk-Kampagnen unterstützt. Bei Displaynetzwerk-Kampagnen können die Kriterien für CriterionUserList auf Kampagnenebene nur ausgeschlossen werden.

  • Das Festlegen der Felder urlCustomParameters, trackingUrlTemplate, finalUrls, finalAppUrls und finalMobileUrls in Suchnetzwerk- und Shopping-Kampagnen wird von Nutzerlistenzielen nicht unterstützt.

Zielgruppentypen in Nutzerlisten

Mithilfe einer UserList lässt sich das Remarketing auf bestimmte Zielgruppen ausrichten. Der Liste können verschiedene Typen von Gruppen zugrunde liegen:

Websitebesucher

Die einfachste Zielgruppenliste besteht aus Besuchern Ihrer Website. Mit den weiter unten beschriebenen erweiterten Strategien ist es aber möglich, Anzeigen beispielsweise nur auf Nutzer auszurichten, die kürzlich eine bestimmte Seite oder eine bestimmte Kombination von Seiten auf Ihrer Website besucht haben.

In allen AdWords-Konten gibt es genau ein Remarketing-Tag auf Kontoebene. Es wird beim Eröffnen des Kontos automatisch erstellt. Das Tag steht auch zur Verfügung, wenn Sie Remarketing noch nicht verwenden. Der erste Schritt besteht darin, mit CustomerService das Remarketing-Tag auf Kontoebene abzurufen:

// 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 Google global site tag.
System.out.printf("Customer ID %s has Google global site tag:%n%s%n",
    customer.getCustomerId(),
    customer.getRemarketingSettings().getGoogleGlobalSiteTag());

Im nächsten Schritt installieren Sie das Remarketing-Tag auf allen Seiten Ihrer Website. Weitere Informationen zum Remarketing

Sie können auch den Tag Assistant in Google Chrome zur Überprüfung der Tag-Installation verwenden.

Als Nächstes erstellen Sie eine Nutzerliste aus den Nutzern, die das Remarketing-Tag ausgelöst haben. Diese Listen erstellen und verwalten Sie mit AdwordsUserListService. Die verschiedenen Arten von Nutzerlisten haben unterschiedliche Eigenschaften. Wenn Sie alle Nutzer erfassen möchten, die eine beliebige Seite auf Ihrer Website besucht haben, können Sie eine ExpressionRuleUserList verwenden (siehe unten). Dabei enthält die URL der besuchten Seite die Domain Ihrer Website. Weitere Informationen zu regelbasierten Remarketing-Listen finden Sie im Abschnitt Remarketing mit regelbasierten Nutzerlisten.

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

Zwei wichtige Attribute einer Nutzerliste sind membershipLifeSpan und status. Mit dem ersten Attribut definieren Sie die Zeitspanne in Tagen, für die ein Nutzer in der Liste bleiben soll. Mit dem zweiten Attribut wird festgelegt, ob neue Nutzer in die Liste aufgenommen werden können.

Der letzte Schritt besteht darin, Anzeigen auf Mitglieder Ihrer Nutzerliste auszurichten. Dieser Vorgang ist ähnlich wie bei anderen Arten von Ausrichtungskriterien in der API. Mit dem folgenden Code wird gezeigt, wie Sie mit einer CriterionUserList die Anzeigen einer Anzeigengruppe auf eine Nutzerliste ausrichten können:

// 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);

Wie bei sonstigen Arten von Kriterien können Sie dem Objekt BiddableAdGroupCriterion andere Properties zuweisen, wie etwa Gebotsüberschreibungen.

Wenn Sie auf Anzeigengruppenebene Kriterien für Nutzerlisten festgelegt haben, aber stattdessen Kriterien auf Kampagnenebene verwenden möchten, müssen Sie die bestehenden Kriterien aus allen aktiven und pausierten Anzeigengruppen der Kampagne entfernen:

// 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()]));

Wenn Sie auf Nutzerlisten auf Anzeigengruppenebene umstellen möchten, müssen Sie die Kriterien für Nutzerlisten auf Kampagnenebene entfernen. Der Vorgang entspricht dem Beispiel oben. Hinweis: Die criterionId ist nicht die dem Kriterium zugrunde liegende Nutzerlisten-ID.

Anzeigen einer Kampagne werden in ähnlicher Weise auf eine Nutzerliste ausgerichtet:

// 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);

Besucher bestimmter Seiten

Mit einer ExpressionRuleUserList können Sie Anzeigen auf Nutzer ausrichten, die bestimmte Seiten oder Bereiche Ihrer Website besucht haben. Dies funktioniert ähnlich wie im Beispiel oben, allerdings erfolgt die Ausrichtung auf einzelne URLs und nicht nur auf die gesamte Domain der Website. Im Abschnitt Regelbasiertes Remarketing finden Sie ein Beispiel und weitere Informationen.

Besucher einer Seite, die eine andere Seite aufgerufen haben

Mithilfe einer CombinedRuleUserList können Anzeigen auf Nutzer ausgerichtet werden, die mehrere Seiten besucht haben. Die Ausrichtung erfolgt dabei wie im vorherigen Beispiel. Der einzige Unterschied: Im ersten Schritt verwenden Sie statt einer ExpressionRuleUserList eine CombinedRuleUserList.

Erstellen Sie zuerst die beiden Regeln:

Java

// Visitors of a page who visited another page.
StringKey urlStringKey = new StringKey("url__");

StringRuleItem site1StringRuleItem = new StringRuleItem();
site1StringRuleItem.setKey(urlStringKey);
site1StringRuleItem.setOp(StringRuleItemStringOperator.EQUALS);
site1StringRuleItem.setValue("example.com/example1");
RuleItem site1RuleItem = new RuleItem();
site1RuleItem.setStringRuleItem(site1StringRuleItem);

StringRuleItem site2StringRuleItem = new StringRuleItem();
site2StringRuleItem.setKey(urlStringKey);
site2StringRuleItem.setOp(StringRuleItemStringOperator.EQUALS);
site2StringRuleItem.setValue("example.com/example2");
RuleItem site2RuleItem = new RuleItem();
site2RuleItem.setStringRuleItem(site2StringRuleItem);

// Create two RuleItemGroups to show that a visitor browsed two sites.
RuleItemGroup site1RuleItemGroup = new RuleItemGroup();
site1RuleItemGroup.setItems(new RuleItem[]{site1RuleItem});
RuleItemGroup site2RuleItemGroup = new RuleItemGroup();
site2RuleItemGroup.setItems(new RuleItem[]{site2RuleItem});

// Create two rules to show that a visitor browsed two sites.
Rule userVisitedSite1Rule = new Rule();
userVisitedSite1Rule.setGroups(new RuleItemGroup[]{site1RuleItemGroup});

Rule userVisitedSite2Rule = new Rule();
userVisitedSite2Rule.setGroups(new RuleItemGroup[]{site2RuleItemGroup});

C#

// Visitors of a page who visited another page. See
// https://developers.google.com/adwords/api/docs/reference/latest/AdwordsUserListService.StringKey
// for more details.
StringKey urlStringKey = new StringKey() {
  name = "url__"
};

StringRuleItem site1StringRuleItem = new StringRuleItem();
site1StringRuleItem.key = urlStringKey;
site1StringRuleItem.op = StringRuleItemStringOperator.EQUALS;
site1StringRuleItem.value = "example.com/example1";
RuleItem site1RuleItem = new RuleItem();
site1RuleItem.Item = site1StringRuleItem;

StringRuleItem site2StringRuleItem = new StringRuleItem();
site2StringRuleItem.key = (urlStringKey);
site2StringRuleItem.op = (StringRuleItemStringOperator.EQUALS);
site2StringRuleItem.value = ("example.com/example2");
RuleItem site2RuleItem = new RuleItem();
site2RuleItem.Item = (site2StringRuleItem);

// Create two RuleItemGroups to show that a visitor browsed two sites.
RuleItemGroup site1RuleItemGroup = new RuleItemGroup();
site1RuleItemGroup.items = new RuleItem[] { site1RuleItem };
RuleItemGroup site2RuleItemGroup = new RuleItemGroup();
site2RuleItemGroup.items = new RuleItem[] { site2RuleItem };

// Create two rules to show that a visitor browsed two sites.
Rule userVisitedSite1Rule = new Rule();
userVisitedSite1Rule.groups = new RuleItemGroup[] { site1RuleItemGroup };

Rule userVisitedSite2Rule = new Rule();
userVisitedSite2Rule.groups = new RuleItemGroup[] { site2RuleItemGroup };

PHP

// Visitors of a page who visited another page.
$site1StringRuleItem = new StringRuleItem();
$site1StringKey = new StringKey();
$site1StringKey->setName('url__');
$site1StringRuleItem->setKey($site1StringKey);
$site1StringRuleItem->setOp(StringRuleItemStringOperator::EQUALS);
$site1StringRuleItem->setValue('example.com/example1');
$site1RuleItem = new RuleItem();
$site1RuleItem->setStringRuleItem($site1StringRuleItem);

$site2StringRuleItem = new StringRuleItem();
$site2StringKey = new StringKey();
$site2StringKey->setName('url__');
$site2StringRuleItem->setKey($site2StringKey);
$site2StringRuleItem->setOp(StringRuleItemStringOperator::EQUALS);
$site2StringRuleItem->setValue('example.com/example2');
$site2RuleItem = new RuleItem();
$site2RuleItem->setStringRuleItem($site2StringRuleItem);

// Create two RuleItemGroups to show that a visitor browsed two sites.
$site1ItemGroup = new RuleItemGroup();
$site1ItemGroup->setItems([$site1RuleItem]);
$site2ItemGroup = new RuleItemGroup();
$site2ItemGroup->setItems([$site2RuleItem]);

// Create two rules to show that a visitor browsed two sites.
$userVisitedSite1Rule = new Rule();
$userVisitedSite1Rule->setGroups([$site1ItemGroup]);
$userVisitedSite2Rule = new Rule();
$userVisitedSite2Rule->setGroups([$site2ItemGroup]);

Perl

# Visitors of a page who visited another page.
my $site1_string_rule_item =
  Google::Ads::AdWords::v201802::StringRuleItem->new({
    key => Google::Ads::AdWords::v201802::StringKey->new(
      {name => "url__"}
    ),
    op    => "EQUALS",
    value => "example.com/example1"
  });
my $site1_rule_item = Google::Ads::AdWords::v201802::RuleItem->new(
  {StringRuleItem => $site1_string_rule_item});
my $site2_string_rule_item =
  Google::Ads::AdWords::v201802::StringRuleItem->new({
    key => Google::Ads::AdWords::v201802::StringKey->new(
      {name => "url__"}
    ),
    op    => "EQUALS",
    value => "example.com/example2"
  });
my $site2_rule_item = Google::Ads::AdWords::v201802::RuleItem->new(
  {StringRuleItem => $site2_string_rule_item});

# Create two RuleItemGroups to show that a visitor browsed two sites.
my $site1_item_group = Google::Ads::AdWords::v201802::RuleItemGroup->new(
  {items => [$site1_rule_item]});
my $site2_item_group = Google::Ads::AdWords::v201802::RuleItemGroup->new(
  {items => [$site2_rule_item]});

# Create two rules to show that a visitor browsed two sites.
my $user_visited_site1_rule = Google::Ads::AdWords::v201802::Rule->new({
    groups => [$site1_item_group]
  });
my $user_visited_site2_rule = Google::Ads::AdWords::v201802::Rule->new({
    groups => [$site2_item_group]
  });

Python

# Visitors of a page who visited another page.
site1_rule_item = {
    'StringRuleItem': {
        'key': {'name': 'url__'},
        'op': 'EQUALS',
        'value': 'example.com/example1'
    }
}
site2_rule_item = {
    'StringRuleItem': {
        'key': {'name': 'url__'},
        'op': 'EQUALS',
        'value': 'example.com/example2'
    }
}

# Create two rules to show that a visitor browsed two sites.
user_visited_site1_rule = {
    'groups': [{
        'items': [site1_rule_item]
    }]
}

user_visited_site2_rule = {
    'groups': [{
        'items': [site2_rule_item]
    }]
}

Ruby

# Visitors of a page who visited another page.
sites = ['example.com/example1', 'example.com/example2']

# Create two rules to show that a visitor browsed two sites.
user_visited_site_rules = sites.map do |site|
  {
    :groups => [
      :items => [
        {
          :xsi_type => 'StringRuleItem',
          :key => {:name => 'url__'},
          :op => 'EQUALS',
          :value => site
        }
 ]]}
end

Kombinieren Sie die Regeln dann mit der CombinedRuleUserList:

Java

// Create the user list where "Visitors of a page who did visit another page".
// To create a user list where "Visitors of a page who did not visit another
// page", change the ruleOperator from AND to AND_NOT.
CombinedRuleUserList combinedRuleUserList = new CombinedRuleUserList();
combinedRuleUserList.setName("Combined rule user list created at " + creationTimeString);
combinedRuleUserList.setDescription("Users who visited two sites.");
combinedRuleUserList.setLeftOperand(userVisitedSite1Rule);
combinedRuleUserList.setRightOperand(userVisitedSite2Rule);
combinedRuleUserList.setRuleOperator(CombinedRuleUserListRuleOperator.AND);

C#

// Create the user list where "Visitors of a page who did visit another page".
// To create a user list where "Visitors of a page who did not visit another
// page", change the ruleOperator from AND to AND_NOT.
CombinedRuleUserList combinedRuleUserList = new CombinedRuleUserList();
combinedRuleUserList.name = "Combined rule user list created at " + creationTimeString;
combinedRuleUserList.description = "Users who visited two sites.";
combinedRuleUserList.leftOperand = userVisitedSite1Rule;
combinedRuleUserList.rightOperand = userVisitedSite2Rule;
combinedRuleUserList.ruleOperator = CombinedRuleUserListRuleOperator.AND;

PHP

// Create the user list where "Visitors of a page who did visit another
// page". To create a user list where "Visitors of a page who did not visit
// another page", change the ruleOperator from AND to AND_NOT.
$combinedUserList = new CombinedRuleUserList();
$combinedUserList->setName(
    sprintf('Combined rule user list created at %s', date('Y-m-d_His'))
);
$combinedUserList->setDescription('Users who visited two sites.');
$operands = self::createCombinedUserListRules();
$combinedUserList->setLeftOperand($operands[0]);
$combinedUserList->setRightOperand($operands[1]);
$combinedUserList->setRuleOperator(
    CombinedRuleUserListRuleOperator::AND_VALUE
);

Perl

# Create the user list where "Visitors of a page who did visit another page".
# To create a user list where "Visitors of a page who did not visit another
# page", change the ruleOperator from AND to AND_NOT.
my $combined_user_list =
  Google::Ads::AdWords::v201802::CombinedRuleUserList->new({
    name         => "Combined rule user list created at ${creation_time}",
    description  => "Users who visited two sites.",
    leftOperand  => $user_visited_site1_rule,
    rightOperand => $user_visited_site2_rule,
    ruleOperator => "AND"
  });

Python

# Create the user list for "Visitors of a page who did visit another page".
# To create a user list for "Visitors of a page who did not visit another
# page", change the ruleOperator from AND to AND_NOT.
combined_user_list = {
    'xsi_type': 'CombinedRuleUserList',
    'name': 'Combined rule user lst create at ${creation_time}',
    'description': 'Users who visited two sites.',
    'leftOperand': user_visited_site1_rule,
    'rightOperand': user_visited_site2_rule,
    'ruleOperator': 'AND'
}

Ruby

# Create the user list where "Visitors of a page who did visit another page".
# To create a user list where "Visitors of a page who did not visit another
# page", change the ruleOperator from AND to AND_NOT.
combined_rule_user_list = {
  :xsi_type => 'CombinedRuleUserList',
  :name =>
    'Combined rule user list "Visitors of a page who did visit another page"',
  :description => 'Users who visited two sites.',
  :left_operand => user_visited_site_rules[0],
  :right_operand => user_visited_site_rules[1],
  :rule_operator => 'AND'
}

Besucher einer Seite, die keine andere Seite aufgerufen haben

Mithilfe einer CombinedRuleUserList können Anzeigen auf Nutzer ausgerichtet werden, die eine bestimmte Seite besucht haben, nicht aber eine andere Seite. Der einzige Unterschied zum vorherigen Beispiel ist, dass statt AND der Operator AND_NOT für die Regel verwendet werden muss.

Nutzer, die bestimmte Aktionen ausgeführt haben

Die Zielgruppenliste kann mit Nutzern gefüllt werden, die bestimmte Aktionen auf Ihrer Website ausgeführt haben. Bei Verwendung von Conversion-Tracking können Sie Anzeigen auf Nutzer ausrichten, die bereits eine Conversion wie etwa einen Kauf auf Ihrer Website ausgeführt haben.

Sie können Anzeigen jedoch auch auf Nutzer ausrichten, die eine bestimmte Aktion auf Ihrer Website ausgeführt haben, die für Sie keine Conversion ist, beispielsweise wenn ein Nutzer einen Artikel in den Einkaufswagen legt und ihn danach wieder löscht, ohne einen Kauf zu tätigen. Diese beiden Anwendungsfälle werden durch die BasicUserList abgedeckt.

Conversion ausgelöst

Wenn Sie noch keinen Conversion-Tracker erstellt haben, können Sie dies mit ConversionTrackerService nachholen und anschließend das Conversion-Tracking-Tag auf Ihrer Website einbinden.

Mitglieder einer BasicUserList sind Nutzer, die mindestens einen Conversion-Tracker auf Ihrer Website ausgelöst haben. Wenn Sie eine BasicUserList erstellen, fügen Sie den Wert des Feldes id in den ConversionTracker ein, der mit der Nutzerliste verknüpft sein soll.

Im folgenden Beispiel wird eine BasicUserList erstellt, die mit zwei Conversion-Trackern verknüpft ist.

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

Aktionen erfassen, die nicht als Conversions eingestuft sind

Sie können eine BasicUserList für Nutzer erstellen, die Aktionen auf Ihrer Website ausgeführt haben, die für Sie keine Conversions sind. Dazu verknüpfen Sie die Liste mit einem ConversionTracker der Kategorie REMARKETING.

Es gibt zwei Möglichkeiten, das Objekt ConversionTracker zu erstellen. Die erste besteht in der Verwendung von ConversionTrackerService. Die zweite besteht darin, das Objekt über AdWords gleichzeitig mit der von Ihnen erstellten und verknüpften BasicUserList automatisch generieren zu lassen. Der folgende Code ist ein Beispiel für die zweite Methode:

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
...

Der Liste ist ein UserListConversionType zugeordnet, es ist jedoch keine id festgelegt. Dadurch wird automatisch ein ConversionTracker der Kategorie REMARKETING generiert.

Sie können das allgemeine Website-Tag von Google für das automatisch generierte ConversionTracker-Objekt wie folgt abrufen:

// 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 Google global site tag.
System.out.println(((AdWordsConversionTracker) page.getEntries()[0]).getGoogleGlobalSiteTag());

Mehrere Nutzerlisten

Vorhandene Nutzerlisten lassen sich mithilfe der UserListLogicalRule-Felder zu einer LogicalUserList kombinieren. Die Regeln in der LogicalUserList sind mit AND verknüpft. Ein Nutzer muss daher jede Regel erfüllen, um in der Liste berücksichtigt zu werden. Sie können jedoch für jede Regel angeben, ob deren Operanden mit AND oder OR verknüpft sind. Mit anderen Worten: Sie können festlegen, ob ein Nutzer ALLE Regelbedingungen erfüllen muss oder nur eine.

Mit Regeln können Sie außerdem andere LogicalUserList-Objekte als Operanden angeben und so eine Baumansicht erstellen. Eine LogicalUserList ist eine sehr wirkungsvolle Methode, um komplexe Hierarchien von Gruppen für die Ausrichtung zu definieren. Es ist möglich, Listen mit verschiedenen AccessReason-Feldern zu kombinieren. Sollte der Zugriff jedoch aufgehoben werden, wird die UserList bei der Auswertung der Regeln der LogicalUserList als Liste ohne Mitglieder behandelt.

Der folgende Code zeigt, wie Sie eine LogicalUserList erstellen, die Nutzer aus einer von zwei BasicUserList enthält:

// 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);

Ähnliche Zielgruppen

Mit einer SimilarUserList lassen sich neue Zielgruppen ansprechen. Mit dieser Nutzerliste erreichen Sie Nutzer mit ähnlichen Merkmalen wie die Nutzer in anderen Listen.

Eine SimilarUserList wird von Google automatisch für jede UserList erstellt. Dabei werden mehrere Faktoren berücksichtigt, wie beispielsweise die Anzahl der Nutzer in der ursprünglichen Liste, wie lange sie schon in der Liste sind, die Arten der Websites, die sie besucht haben, und ob die Liste Ihre eigene ist. Dieser Vorgang kann bis zu vier Tage ab dem Erstellungsdatum der ursprünglichen Liste dauern.

Der folgende Code zeigt, wie Sie alle verfügbaren SimilarUserList-Objekte finden:

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

Kundenabgleich mit E-Mail-Adressen

Für Werbetreibende mit umfangreichen CRM-Datenbanken lassen sich Zielgruppenlisten definieren und Anzeigen auf der Grundlage der CRM-Daten ausrichten. Sie können CRM-Daten im Bulk-Verfahren hochladen, Daten anhängen und entfernen oder diese Nutzerlisten verwenden, um eine LogicalUserList zu erstellen.

Diese Zielgruppenlisten können für die Google-Suche, YouTube und Gmail, nicht jedoch für das Google Displaynetzwerk bereitgestellt werden.

Gemäß Richtlinie dürfen Sie nur Erstanbieterdaten hochladen, also Daten, die Sie selbst erfasst haben. Es ist nicht zulässig, E-Mail-Listen von Dritten zu erwerben und in das Konto hochzuladen.

Aus Datenschutzgründen müssen E-Mail-Adressen sowie Vor- und Nachnamen mit dem SHA-256-Algorithmus gehasht werden, bevor sie hochgeladen werden. Um die Hash-Ergebnisse zu standardisieren, müssen Sie vor dem Hash-Vorgang für eine E-Mail-Adresse

  • eventuell vorhandene Leerzeichen am Anfang und Ende entfernen und

  • die E-Mail-Adresse komplett in Kleinbuchstaben umwandeln.

Ein vollständiges Beispiel dafür, wie Sie richtig standardisierte und gehashte Daten von Mitgliedern hinzufügen, finden Sie unten im Abschnitt Codebeispiele.

Es gibt je nach Kampagnentyp unterschiedliche Möglichkeiten zum Kundenabgleich:

Kampagnen vom Typ "Nur Suchnetzwerk"
Eine CrmBasedUserList ist verfügbar. Anzeigen werden im Suchnetzwerk ausgeliefert.
Kampagnen vom Typ "Nur Displaynetzwerk"
Eine CrmBasedUserList und deren SimilarUserList sind verfügbar. Anzeigen werden in Gmail nur ausgeliefert, wenn GSP-Creatives vorhanden sind.
Kampagnen vom Typ "Suchnetzwerk mit Displayauswahl"
Eine CrmBasedUserList ist verfügbar. Anzeigen werden im Suchnetzwerk und in Gmail (nur wenn GSP-Creatives vorhanden sind) ausgeliefert.
Videokampagnen
Eine CrmBasedUserList und deren SimilarUserList sind verfügbar. Auf YouTube werden nur In-Stream-TrueView-Anzeigen ausgeliefert.

Wichtige Hinweise

  • Von der API wird die Anzahl der E-Mail-Adressen in einer Mutate-Anforderung beschränkt.

  • Das MembershipLifeSpan-Limit einzelner Nutzerlisten kann unterschiedlich sein.

  • Es dauert sechs bis zwölf Stunden, bis Mitglieder in eine Liste aufgenommen werden. Daher wird auf der AdWords-Benutzeroberfläche wahrscheinlich der Status "In Bearbeitung" angezeigt, wenn Sie innerhalb von zwölf Stunden mehrmals Zielgruppenlisten hochladen.

  • E-Mail-Adressen müssen zu einem Google-Konto gehören.

  • Zur Ausrichtung in Gmail können nur @gmail.com-Adressen verwendet werden.

  • Aus Datenschutzgründen wird die Größe der Nutzerliste als null angezeigt, bis sie mindestens 1.000 Mitglieder enthält. Danach wird die Größe auf die beiden signifikantesten Stellen gerundet.

  • Laden Sie mindestens 5.000 E-Mail-Adressen in die Liste hoch, um sicherzustellen, dass Anzeigen ausgeliefert werden.

  • Eine CrmBasedUserList kann nur mit einer weiteren CrmBasedUserList kombiniert werden, wenn eine LogicalUserList verwendet wird. Alle Richtlinien für CrmBasedUserList gelten auch für die resultierende Nutzerliste.

Kundenabgleich mit Telefonnummer

Ähnlich wie beim Kundenabgleich mithilfe von E-Mail-Adressen können Sie auch die Telefonnummern für einen Abgleich verwenden.

Aus Datenschutzgründen müssen Telefonnummern vor dem Hochladen mit dem SHA-256-Algorithmus gehasht werden. Wandeln Sie die Telefonnummern vor dem Hashen in das E164-Format um, sodass Sie standardisierte Ergebnisse erhalten. Bei diesem Format können Telefonnummern bis zu 15 Ziffern lang sein und beginnen mit einem +-Zeichen (z. B. +12125650000 oder +442070313000).

Kundenabgleich mit Mobilgeräte-IDs

Ähnlich wie beim Kundenabgleich mithilfe von E-Mail-Adressen können Sie auch die Mobilgeräte-IDs (Identifier for Advertising, kurz IDFA, oder Android Advertising ID, kurz für AAID) für einen Abgleich verwenden.

Ausrichtungseinstellungen für Remarketing

Nachdem Sie einer Anzeigengruppe oder Kampagne eine Nutzerliste als Kriterium hinzugefügt haben, kann es losgehen. Allerdings ist die Ausrichtung möglicherweise nicht genau wie von Ihnen erwartet. Prüfen Sie, ob sie wie beabsichtigt funktioniert, indem Sie sich die Einstellung TargetingSetting der Anzeigengruppen oder Kampagnen ansehen, für die die neue Liste verwendet wird. Rufen Sie hierzu die entsprechenden getSettings-Methoden auf.

Mit TargetingSettingDetail-Objekten können Sie genau festlegen, wie die verschiedenen Kriterientypen zur Ausrichtung verwendet werden. In jedem TargetingSettingDetail-Objekt können Sie angeben, ob beim Kriterientyp das Schema Bid only oder Target and bid verwendet wird.

Wenn Sie Bid only verwenden, werden die Kriterien nicht zur Einschränkung der Zugriffe verwendet, Sie können jedoch für unterschiedliche Nutzer in Ihren Listen unterschiedliche Gebote angeben. Mit dem Schema Target and bid kann mit den Kriterien der Zugriff auf Anzeigengruppen auf Nutzer in den Nutzerlisten beschränkt werden.

Die Standardausrichtung für Remarketing-Listen ist Target and bid. Wenn Sie Ihrer Hauptkampagne im Suchnetzwerk Remarketing-Listen hinzufügen, sollten Sie die Ausrichtungseinstellung auf Bid only festlegen. Belassen Sie die Ausrichtung auf Target and bid, wenn Sie eine duplizierte Kampagne mit Remarketing-Listen für Suchanzeigen einrichten.

In diesem Beispiel wird die Java-Clientbibliothek verwendet, um das TargetingSettingDetail für eine Anzeigengruppe auf Bid only festzulegen:

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

Bei Kampagnen ist das Verfahren für die Festlegung auf Bid only oder Target and bid nahezu identisch. Verwenden Sie die Methode getSettings und setSettings des Objekts Campaign wie für AdGroup gezeigt.

Leistungsberichte

Der Leistungsbericht nach Zielgruppe enthält die zum Erstellen von Leistungsberichten aus Ihren Nutzerlisten erforderlichen Felder. So könnten Sie beispielsweise mithilfe der Felder Conversions oder CostPerConversion in diesem Bericht feststellen, ob die Ausrichtung auf Mitglieder der Liste tatsächlich zu mehr Conversions führt, und die Gebotsanpassungen entsprechend ändern. Oder Sie ermitteln die für einzelne Klicks verantwortliche Nutzerliste, indem Sie das Feld UserListId in den Bericht zur Klickleistung aufnehmen. Weitere Informationen

Remarketing mit regelbasierten Nutzerlisten

Mit regelbasierten Nutzerlisten können Sie eine Zielgruppe für Ihre Anzeigen definieren, die auf integrierten Remarketing-Tag-Parametern basiert oder auf benutzerdefinierten Parametern, die Sie dem Remarketing-Tag hinzufügen. Nachdem Sie eine Nutzerliste eingerichtet und Ihrer Website oder mobilen App das Remarketing-Tag hinzugefügt haben, können Sie Ihre Anzeigen auf Nutzer in der Liste ausrichten, unterschiedliche Gebote für diese Nutzer angeben und Berichte erstellen, in denen die Statistiken auf Basis der Mitglieder der Liste strukturiert oder gefiltert werden.

Da in diesem Abschnitt der Schwerpunkt auf regelbasierten Listen liegt, sind darin Beispiele zum Erstellen einer ExpressionRuleUserList und einer DateSpecificRuleUserList enthalten.

Vertrauliche Nutzerdaten dürfen nicht zum Erstellen von Remarketing-Listen verwendet werden. Lesen Sie die Richtlinie zu personalisierter Werbung, bevor Sie eine Remarketing-Kampagne einrichten und Ihrer Website oder App das Remarketing-Tag hinzufügen.

Integrierte Remarketing-Tag-Parameter verwenden

Mit dem integrierten Remarketing-Parameter url__ können Ihre Anzeigen auf eine Nutzerliste auf Basis der URLs ausgerichtet werden, die Nutzer auf Ihrer Website besucht haben. Der Code unten zeigt, wie Sie eine regelbasierte Nutzerliste für Nutzer erstellen, die Seiten in zwei unterschiedlichen Bereichen Ihrer Website besucht haben. Bei Verwendung eines integrierten Remarketing-Parameters müssen Sie keine Änderungen am Remarketing-Tag vornehmen.

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

Benutzerdefinierte Remarketing-Tag-Parameter verwenden

Sie können dem Remarketing-Tag benutzerdefinierte Parameter hinzufügen, um individuelle Nutzerlisten zu erstellen.

Beispiel

Auf Ihrer Website sind mehrere benutzerdefinierte Parameter für das Remarketing-Tag konfiguriert, um die folgenden Nutzerattribute zu erfassen:

  • ecomm_pagetype: Kategorie der Seite Ihrer Website, z. B. Kasse oder Einkaufswagen
  • cartsize: Anzahl der Artikel im Einkaufswagen eines Nutzers
  • checkoutdate: Datum, an dem ein Nutzer den Kaufvorgang abgeschlossen hat. Sie legen diesen Parameter nur dann fest, wenn ein Nutzer tatsächlich einen Kaufvorgang abgeschlossen hat.

Sie möchten mit Nutzern, die mehrere Artikel in ihre Einkaufswagen gelegt haben und zur Kasse gegangen sind, mehr Impressionen erzielen. Außerdem möchten Sie Nutzer ermitteln, die im November und Dezember etwas gekauft haben, da Sie für diese Monate eine große Sonderaktion auf Ihrer Website planen.

Sie können diese Gruppe von Nutzern mit den folgenden Regeln beschreiben:

  1. Nutzer, die die Zahlungsseite besucht und mehr als einen Artikel in den Einkaufswagen gelegt haben.
  2. Nutzer, die im November oder Dezember die Zahlungsseite besucht haben.

Wenn ein Nutzer unter Kategorie 1 oder 2 fällt, sollen die Gebote in bestimmten Anzeigengruppen oder Kampagnen um 25 % erhöht werden.

Objekte

Werfen Sie einen Blick auf die Struktur einer regelbasierten Nutzerliste, bevor Sie sich mit dem Code beschäftigen. Eine regelbasierte Nutzerliste wird in der AdWords API als RuleBasedUserList angegeben. Das Diagramm unten zeigt, wie die RuleBasedUserList für diesen Anwendungsfall am Schluss aussehen wird.

Diagram of a rule based user list's structure

Erste RuleItemGroup erstellen

Erstellen Sie zunächst die erste RuleItemGroup auf der linken Seite. Sie besteht aus zwei RuleItems:

  1. Nutzer, die die Zahlungsseite besucht haben
  2. Nutzer mit mehr als einem Artikel im Einkaufswagen

Im ersten Element wird der Parameter ecomm_pagetype mit Stringwerten verwendet. Deshalb sollten Sie zunächst ein StringRuleItem erstellen.

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

Das zweite Element verwendet den Parameter cartsize mit numerischen Werten. Sie benötigen daher ein NumberRuleItem.

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

Als Nächstes kombinieren Sie die beiden RuleItems in einer RuleItemGroup. Wenn Elemente zu einer Gruppe zusammengefasst werden, werden die zugehörigen Regeln in AdWords normalerweise nach dem AND-Prinzip kombiniert. Weitere Informationen finden Sie unten im Abschnitt zum Erstellen der Nutzerliste.

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

Zweite RuleItemGroup erstellen

Die RuleItemGroup rechts besteht aus zwei RuleItem-Objekten.

  1. Nutzer, die nach dem 31. Oktober die Zahlungsseite besucht haben
  2. Nutzer, die vor dem 1. Januar die Zahlungsseite besucht haben

Bei beiden Elementen wird der Parameter checkoutdate verwendet. Da dieser Datumswerte aufnimmt, erstellen Sie DateRuleItem-Objekte.

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

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

Kombinieren Sie analog zur Gruppe links diese beiden RuleItem-Objekte in einer RuleItemGroup, um sie mit AND zu verbinden.

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

Nutzerliste erstellen

Für die ExpressionRuleUserList ist eine weitere Unterscheidung erforderlich. In AdWords werden alle Regelelemente in einer entsprechenden Gruppe standardmäßig nach dem AND-Prinzip kombiniert. Das bedeutet, jedes Regelelement muss in mindestens einer Regelelementgruppe übereinstimmen, damit ein Besucher über die Regel der Liste hinzugefügt wird. Dies wird als disjunktive Normalform (Disjunctive Normal Form, DNF) bezeichnet.

Sie könnten die Liste stattdessen auch so einrichten, dass ein Besucher nur dann hinzugefügt wird, wenn mindestens ein Regelelement in jeder Regelelementgruppe übereinstimmt. Dies wird als konjunktive Normalform (Conjunctive Normal Form, CNF) bezeichnet und ist für die ExpressionRuleUserList verfügbar. Hierzu muss das Feld ruleType verwendet werden. Beim Versuch, CNF für eine DateSpecificRuleUserList zu verwenden, wird ein Fehler ausgegeben.

Jetzt müssen nur noch die Regelelementgruppen von oben in einer neuen Nutzerliste kombiniert werden: In diesem Fall verwenden wird die DNF-Standardfunktion, da wir die Regeln eigens dafür erstellt haben.

// 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});
rule.setRuleType(UserListRuleType.DNF);
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});

Beschränkung auf den Zeitraum

Die ExpressionRuleUserList von oben entspricht Ihren Anforderungen. Doch wie gehen Sie vor, wenn Sie nur Nutzer erfassen möchten, die der Regel in dieser Liste entsprechen und Ihre Website zwischen dem 1. Oktober und 31. Dezember besuchen? Dazu verwenden Sie die DateSpecificRuleUserList.

Beim Erstellen einer DateSpecificUserList gehen Sie genauso vor wie bei einer ExpressionRuleUserList, legen zusätzlich jedoch startDate und endDate der Liste fest.

DateSpecificRuleUserList dateRuleUserList = new DateSpecificRuleUserList();
dateRuleUserList.setStartDate(startDate.toString("20171001"));
dateRuleUserList.setEndDate(endDate.toString("20171231"));

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

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

Das war schon alles. Die neue Liste enthält alle Nutzer, die dieselben Regeln wie die vorherige Liste erfüllen. Es sind jedoch nur Nutzer enthalten, die Ihre Websites zwischen startDate (einschließlich) und endDate (einschließlich) besuchen. In der Dokumentation zur DateSpecificRuleUserList finden Sie Informationen zu anderen Optionen (z. B. offenes Start- und Enddatum).

Frühere Nutzer in die Liste einschließen

Sie können auch frühere Nutzer in regelbasierte Nutzerlisten einschließen. Hierzu setzen Sie den prepopulationStatus der Nutzerliste auf REQUESTED. Sie sollten den Status dieses Felds regelmäßig überprüfen, um den Fortschritt der asynchronen Vorauffüllung zu kontrollieren.

Gebote für Nutzer in der Liste ändern

Sie haben bereits eine Nutzerliste erstellt und das Remarketing-Tag auf Ihrer Website eingerichtet. Jetzt möchten Sie Anzeigengruppen oder Kampagnen gezielt auf Mitglieder der Liste ausrichten, indem Sie die entsprechenden Gebote um 25 % erhöhen.

So ändern Sie die Gebote für bestimmte Anzeigengruppen:

// 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()]));

Gebote für eine Kampagne lassen sich ähnlich ändern:

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

Weitere Optionen für Nutzerlisten

Sie können die Ausrichtung mit regelbasierten Nutzerlisten weiter präzisieren, indem Sie sie mit anderen Nutzerlisten kombinieren. Wenn Sie beispielsweise eine BasicUserList verwenden, die auf einen bestimmten Conversion-Typ ausgerichtet ist, und eine RuleBasedUserList, die mit benutzerdefinierten Parametern auf Nutzer ausgerichtet ist, können Sie Ihre Anzeigen mithilfe einer LogicalUserList auf die Mitglieder beider Listen ausrichten. Ein Beispiel finden Sie weiter oben im Abschnitt Mehrere Nutzerlisten.

Remarketing-Tag zur Website hinzufügen

Damit Ihre regelbasierte Nutzerliste gefüllt wird, müssen Sie Ihrer Website das Remarketing-Tag auf Kontoebene hinzufügen. Wenn Sie nur integrierte Remarketing-Tag-Parameter verwenden, sind keine Änderungen am Remarketing-Tag erforderlich. Bei Verwendung von benutzerdefinierten Parametern finden Sie Informationen zum Bearbeiten des Tags zur Aufnahme dieser Parameter im Artikel Erweiterte Strategien zum Taggen und Erstellen von Remarketing-Listen.

Codebeispiele

Vollständige Codebeispiele zum Hinzufügen einer regelbasierten Nutzerliste finden Sie im Ordner Remarketing der jeweiligen Clientbibliothek:

Feedback geben zu...