Remarketing und Ausrichtung auf Zielgruppen

Mit Remarketing können Sie Nutzern, die bereits Ihre Website besucht oder Ihre mobile App verwendet haben oder in Ihren CRM-Datenbanken enthalten sind, relevante Anzeigen präsentieren, während sie andere Websites besuchen oder eine Suchanfrage auf Google durchführen. Für Remarketing verwendete Nutzerlisten können auch für andere Arten von Ausrichtung auf Zielgruppen wie etwa Kundenabgleich verwendet werden.

In diesem Leitfaden werden die folgenden Themen behandelt:

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

Zielgruppentypen in Nutzerlisten

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

Besucher Ihrer Website

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

Im nächsten Schritt installieren Sie das Remarketing-Tag, über das Sie auf Kontoebene verfügen, auf allen Seiten Ihrer Website. Weitere Informationen zum Hinzufügen des Remarketing-Tags auf Ihrer Website oder in Ihrer mobilen App

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

Nun müssen Sie eine Nutzerliste aus den Nutzern erstellen, die das Remarketing-Tag ausgelöst haben. Nutzerlisten 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 können Sie die Zeitspanne in Tagen definieren, für die ein Nutzer als in der Liste enthalten angesehen wird. 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. Der folgende Code zeigt, wie Sie mit einer CriterionUserList eine Anzeigengruppe auf eine Nutzerliste ausrichten:

// 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 BiddableAdGroupCriterion-Objekt andere Properties zuweisen, wie etwa Gebotsüberschreibungen.

Wenn Sie Nutzerlistenkriterien auf Anzeigengruppenebene festgelegt haben, aber stattdessen Kriterien auf Kampagnenebene verwenden möchten, müssen Sie erst 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 auf Kampagnenebene vorhandenen Nutzerlistenkriterien entfernen. Der Vorgang ist wie im Beispiel oben. Zu beachten: 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, doch erfolgt die Ausrichtung auf einzelne URLs und nicht auf die gesamte Domain der Website. Unter Regelbasiertes Remarketing finden Sie ein Beispiel und weitere Informationen.

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. Anschließend können Sie das Conversion-Tracking-Snippet auf Ihrer Website installieren.

Mitglieder einer BasicUserList sind Nutzer, die mindestens einen Conversion-Tracker auf Ihrer Website ausgelöst haben. Beim Erstellen einer BasicUserList 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 vorhandenen 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);

Nicht-Conversion-Aktionen

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, ein ConversionTracker-Objekt zu erstellen. Die erste besteht in der Verwendung von ConversionTrackerService. Die zweite Möglichkeit besteht darin, es von AdWords zusammen mit der von Ihnen erstellten 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
...

Die Liste enthält einen UserListConversionType, eine id ist jedoch nicht festgelegt. Dadurch wird automatisch ein ConversionTracker-Objekt der Kategorie REMARKETING generiert.

Sie können das Code-Snippet 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 code snippet.
System.out.println(((AdWordsConversionTracker) page.getEntries()[0]).getSnippet());

Mehrere Nutzerlisten

Über UserListLogicalRule-Felder haben Sie die Möglichkeit, vorhandene Nutzerlisten nach Ihren Wünschen zu einer LogicalUserList zu 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 ihre 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 aufgehoben werden, wird die UserList bei der Auswertung der Regeln der LogicalUserList aber 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 haben Sie die Möglichkeit, neue Zielgruppen anzusprechen. Mit dieser Nutzerliste können Sie Nutzer erreichen, die ähnliche Eigenschaften wie die Nutzer in anderen Nutzerlisten aufweisen.

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

Für Werbetreibende mit umfangreichen CRM-Datenbanken lassen sich Zielgruppenlisten definieren und Anzeigen auf den CRM-E-Mail-Daten basierend ausrichten. Sie können E-Mail-Adressen anfügen, entfernen, in einem Bulk-Vorgang hochladen oder anhand der Nutzerlisten eine LogicalUserList erstellen.

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

Gemäß der Richtlinie dürfen Sie nur E-Mail-Adressen hochladen, die Sie selbst gesammelt haben (Erstanbieter). Sie dürfen also keine E-Mail-Listen von Dritten erwerben und in das Konto hochladen.

Aus Datenschutzgründen müssen E-Mail-Adressen vor dem Hochladen mit dem SHA-256-Algorithmus gehasht werden. Daher müssen Sie vor dem Hashen einer E-Mail-Adresse

  • Leerzeichen am Anfang und Ende entfernen.

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

Der folgende Code zeigt, wie Sie eine CrmBasedUserList erstellen und drei Mitglieder mit drei unterschiedlichen E-Mail-Adressen hinzufügen, die jeweils entsprechend standardisiert und gehasht wurden.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  return result.toString();
}

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

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

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

Kampagnen vom Typ "Nur Suchnetzwerk"
Eine CrmBasedUserList ist verfügbar. Anzeigen werden im Suchnetzwerk geschaltet.
Kampagnen vom Typ "Nur Displaynetzwerk"
Eine CrmBasedUserList und ihre SimilarUserList sind verfügbar. Anzeigen werden in Gmail nur geschaltet, 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) geschaltet.
Videokampagnen
Eine CrmBasedUserList und ihre 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 kann mehrere Stunden dauern, bis die Liste mit Mitgliedern gefüllt ist.

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

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. Um zu sehen, ob sie wie beabsichtigt funktioniert, überprüfen Sie die TargetingSetting der Anzeigengruppen oder Kampagnen, für die die neue Liste verwendet wird. Rufen Sie hierzu die entsprechenden getSettings-Methoden auf.

Mit einer Reihe von TargetingSettingDetail-Objekten können Sie genau festlegen, wie die verschiedenen Kriterientypen zur Ausrichtung verwendet werden. In jedem TargetingSettingDetail können Sie angeben, ob ein Kriterientyp das Schema Nur Gebot oder Ausrichtung und Gebot verwenden soll.

Wenn Sie Nur Gebot verwenden, werden die Kriterien nicht zur Einschränkung der Zugriffe verwendet, doch können Sie für unterschiedliche Nutzer in Ihren Listen unterschiedliche Gebote abgeben. Mit dem Schema Ausrichtung und Gebot kann mit den Kriterien der Zugriff auf Anzeigengruppen auf Nutzer in den Nutzerlisten beschränkt werden.

Die Standardausrichtung für Remarketing-Listen ist Ausrichtung und Gebot. Wenn Sie Ihrer Hauptkampagne im Suchnetzwerk Remarketing-Listen hinzufügen, sollten Sie die Ausrichtungseinstellung auf Nur Gebot festlegen. Belassen Sie die Ausrichtung auf Ausrichtung und Gebot, 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 Nur Gebot 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 Nur Gebot oder auf Ausrichtung und Gebot fast identisch. Verwenden Sie die getSettings- und setSettings-Methoden von Campaign-Objekten wie für AdGroup gezeigt.

Leistungsberichte

Der Leistungsbericht nach Zielgruppe enthält die zur Erstellung 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 finden Sie im Leitfaden für Berichte.

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 Ihrem 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 abgeben 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 für die Erstellung einer ExpressionRuleUserList und einer DateSpecificRuleUserList enthalten.

Vertrauliche Nutzerinformationen 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 keinerlei Änderungen an Ihrem 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 Ihrem Remarketing-Tag benutzerdefinierte Parameter hinzufügen, um individuellere Nutzerlisten zu erstellen.

Szenario

Angenommen, auf Ihrer Website sind mehrere benutzerdefinierte Remarketing-Tag-Parameter 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 String-Werten 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 jetzt 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 in einer Elementgruppe kombiniert werden, werden ihre Regeln von AdWords mit AND verbunden.

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

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

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

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

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

Nun müssen nur noch die Regelelementgruppen von oben in einer neuen Nutzerliste kombiniert werden:

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

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

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

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

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

Auf Zeitraum des Websitebesuchs einschränken

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

Gehen Sie beim Erstellen einer DateSpecificUserList genauso vor wie bei einer ExpressionRuleUserList. Legen Sie jedoch zusätzlich startDate und endDate der Liste fest.

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

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

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

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 wie etwa offene Start- und Enddaten.

Frühere Nutzer in die Liste einschließen

Ab Version 201702 können Sie auch frühere Nutzer in regelbasierte Nutzerlisten einschließen. Hierzu setzen Sie den prepopulationStatus der Nutzerliste auf REQUESTED. Überprüfen Sie regelmäßig den Status dieses Felds, um den Fortschritt des asynchronen Vorauffüllungsprozesses 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 speziell auf Mitglieder der Liste ausrichten, indem Sie die entsprechenden Gebote um 25 % erhöhen.

So werden die Gebote für bestimmte Anzeigengruppen geändert:

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

Zusätzliche Optionen für Nutzerlisten

Sie können mit regelbasierten Nutzerlisten eine noch ausgefeiltere Ausrichtung erreichen, wenn Sie sie mit anderen Nutzerlisten kombinieren. Wenn Sie beispielsweise eine BasicUserList verwenden, die auf einen bestimmten Conversion-Typ ausgerichtet ist, und eine RuleBasedUserList, die anhand benutzerdefinierter Parameter auf Nutzer ausgerichtet ist, können Sie mithilfe einer LogicalUserList Ihre Anzeigen auf Mitglieder in beiden Listen ausrichten. Ein Beispiel finden Sie weiter oben im Abschnitt Mehrere Nutzerlisten.

Remarketing-Tag Ihrer Website hinzufügen

Damit Ihre regelbasierte Nutzerliste gefüllt wird, müssen Sie Ihrer Website das Remarketing-Tag auf Kontoebene hinzufügen. Gehen Sie anhand der Anleitung oben vor, um das Tag abzurufen und auf Ihrer Website zu installieren.

Wenn Sie nur integrierte Remarketing-Tag-Parameter verwenden, müssen Sie keinerlei Änderungen an Ihrem Remarketing-Tag vornehmen. Bei Verwendung von benutzerdefinierten Parametern finden Sie Informationen zum Bearbeiten Ihres 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...