Marketing API

Dynamische Produktzielgruppen

Mit Advantage+ Catalog Ads kannst du Personen Werbung zeigen, die auf ihrer geräteübergreifenden Kaufabsicht basiert. Du kannst Anzeichen für Absicht von mobilen Apps und Websites sammeln und diese Daten dazu verwenden, um eine Zielgruppe zu erstellen. So kannst du direkt auf potenzielle Kund*innen abzielen.

In diesem Dokument wird Folgendes behandelt:

Schritt 1: Nutzungssignale für Events einrichten

Verwende App-Events für deine mobile App oder Meta-Pixel für deine Website, um Nutzungssignale zu erfassen.

Wenn du über eine App verfügst und Anzeigen nur auf Desktops ausführst, solltest du das Facebook-SDK installieren. Somit kannst du Signale erfassen und deine Zielgruppe erweitern.

App-Events bei mobilen Apps

Du musst die folgenden Events über das Facebook-SDK für iOS und Android zu deiner App hinzufügen:

EventiOS EventAndroid Event

Suche

FBSDKAppEventNameSearched

EVENT_NAME_SEARCHED

Inhalt anzeigen

FBSDKAppEventNameViewedContent

EVENT_NAME_VIEWED_CONTENT

In den Einkaufswagen

FBSDKAppEventNameAddedToCart

EVENT_NAME_ADDED_TO_CART

Kauf

// Über logPurchase senden
[[FBSDKAppEvents shared] logPurchase:(double) currency:(NSString *) parameters:(NSDictionary *)];

EVENT_NAME_PURCHASED

Alle diese Events sollten eine content_id (oder ein JSON-Array von content_ids) enthalten.

Anders als Meta-Pixel verfügt App-Events nicht über einen product_catalog_id-Parameter. Deshalb musst du zwischen deinem Katalog und der App eine Verbindung herstellen, indem du den unten beschriebenen external_event_sources-Endpunkt verwendest.

Beispiele

Event „Add To Cart“ auf iOS:

[[FBSDKAppEvents shared] logEvent:FBSDKAppEventNameAddedToCart
      valueToSum:54.23
      parameters:@{
        FBSDKAppEventParameterNameCurrency    : @"USD",
        FBSDKAppEventParameterNameContentType : @"product",
        FBSDKAppEventParameterNameContentID   : @"123456789"
      }
];

Kauf-Event für iOS mit zwei unterschiedlichen gekauften Artikeln unter Angabe von Menge:

[[FBSDKAppEvents shared] logPurchase:21.97
    currency:@"USD"
    parameters:@{
      FBSDKAppEventParameterNameContent   : @"[{\"id\":\"1234\",\"quantity\":2},{\"id\":\"5678\",\"quantity\":1}]",
      FBSDKAppEventParameterNameContentType : @"product"
    }
];

Kauf-Event für Android mit zwei gekauften Artikeln unter Angaben von Menge:

Bundle parameters = new Bundle();
parameters.putString(AppEventsConstants.EVENT_PARAM_CURRENCY, "USD");
parameters.putString(AppEventsConstants.EVENT_PARAM_CONTENT_TYPE, "product");
parameters.putString(AppEventsConstants.EVENT_PARAM_CONTENT, "[{\"id\":\"1234\",\"quantity\":2},{\"id\":\"5678\",\"quantity\":1}]");

logger.logEvent(
  AppEventsConstants.EVENT_NAME_PURCHASED,
  21.97,
  parameters
);

Kauf-Event für Android mit zwei gekauften Artikeln:

Bundle parameters = new Bundle();
parameters.putString(AppEventsConstants.EVENT_PARAM_CURRENCY, "USD");
parameters.putString(AppEventsConstants.EVENT_PARAM_CONTENT_TYPE, "product");
parameters.putString(AppEventsConstants.EVENT_PARAM_CONTENT_ID, "[\"1234\",\"5678\"]");

logger.logEvent(
  AppEventsConstants.EVENT_NAME_PURCHASED,
  21.97,
  parameters
);

Beachte, dass entweder CONTENT_ID oder CONTENT mit Advantage+ Catalog Ads verwendet werden kann, um Produkt-IDs zu melden. Mit dem CONTENT-Parameter kannst du zusätzliche Informationen zu den Produkten angeben.

Verwendung eines Mobile Measurement Partner

Wenn du Advantage+ Catalog Ads mit einem Mobile Measurement Partner (MMP) verwenden möchtest, solltest du getrennte erforderliche Events auslösen, wenn jemand deine App benutzt. Die wichtigsten Punkte der Interaktion, die du verfolgen solltest, sind Folgende: Wenn jemand nach Produkten sucht, ein Produkt anzeigt, Artikel zum Einkaufswagen hinzufügt und Artikel kauft. Du solltest die Events bei deinem MMP auswählen, die mit den folgenden standardmäßigen Advantage+ Catalog Ads übereinstimmen:

NameBeschreibung

fb_mobile_search

Jemand sucht nach Produkten

fb_mobile_content_view

Wenn ein Konto der Kontenübersicht ein Produkt anzeigt

fb_mobile_add_to_cart

Jemand legt einen Artikel in den Einkaufswagen

fb_mobile_purchase

Ein Konto der Kontenübersicht kauft einen oder mehrere Artikel

Außerdem benötigst du zwei zusätzliche Parameter, damit jedes der Events erfolgreich als gültiges Advantage+ Catalog Ads-Event registriert wird. Diese beiden Parameter entsprechen der ID des Artikels, der angezeigt, zum Einkaufswagen hinzugefügt oder gekauft wird, und zeigen an, ob die ID zu einem einzelnen Produkt oder zu einer Produktgruppe gehört. Die verfügbaren zusätzlichen Parameter sind die Folgenden:

NameBeschreibung

fb_content_id

String

Entweder fb_content_id oder fb_content ist erforderlich.
Die Produkt- oder Produktgruppen-ID(s) des Einzelhändlers. Dabei sollte es sich um einen String mit einem im JSON-Format verschlüsselten Array von IDs handeln. Verwende nach Möglichkeit Produkt-IDs für ein genaueres Targeting.

fb_content

String

Entweder fb_content_id oder fb_content ist erforderlich.
Eine Liste mit JSON-Objekten, die die internationale Artikelnummer (EAN) oder (eine) andere Produkt- oder Inhalts-ID(s) sowie Mengen und Preise der Produkte enthält.


Die Felder id und quantity sind die erforderlichen.
Beispiel:
"[{\"id\": \"1234\", \"quantity\": 2}, {\"id\": \"5678\", \"quantity\": 1}]"

fb_content_type

String

Optional.
Entweder product oder product_group, der mit dem ID-Typ synchronisiert werden muss, der als fb_content_id verwendet wird.


Wenn kein fb_content_type angegeben wird, ordnet Meta das Event jedem Artikel mit derselben ID zu, unabhängig vom Typ.


Mehr dazu erfährst du unter „Auswählen des richtigen content_type“.

_valueToSum

String

Optional.
Der Gesamtwert der Produkte.

fb_currency

String

Optional.
Die Währung des Produkts oder Kaufbetrags.

Hinweis: Die Parameter _valueToSum und fb_currency sollten beim Tätigen eines Kaufs gesendet werden.

Meta-Pixel für Websites verwenden

Du musst ggf. folgende Events zu deiner Website hinzufügen:

  • Search
  • ViewCategory
  • ViewContent
  • AddToCart
  • Purchase

Diese Events müssen zusammen mit den folgenden Datenparametern gesendet werden:

NameBeschreibung

content_ids

string oder string[]

Entweder content_ids oder contents ist erforderlich.
Die ID(s) des Produkts/der Produktgruppe des Einzelhändlers. Verwende nach Möglichkeit Produkt-IDs für ein genaueres Targeting.

contents

object[]

Entweder content_ids oder contents ist erforderlich.
Eine Liste von JSON-Objekten mit den IDs der Produkte oder Produktgruppen des Händlers sowie mit zusätzlichen Informationen über die Produkte.


Die Felder id und quantity sind erforderlich
Beispiel:. [{"id": "1234", "quantity": 2}, {"id": "5678", "quantity": 1}]

content_type

String

Optional.
Entweder product oder product_group, der mit dem ID-Typ synchronisiert werden muss, der als content_ids verwendet wird.


Wenn kein content_type angegeben wird, ordnet Meta das Event jedem Artikel mit derselben ID zu, unabhängig vom Typ.


Mehr dazu erfährst du unter „Auswählen des richtigen content_type“.

product_catalog_id

String

Optional.
Der zu verwendende Produktkatalog. Wenn ein Katalog bereitgestellt wird, ist dies der einzige Katalog, dem Feueraktionen des Pixels zugewiesen werden. Andernfalls werden die Kataloge verwendet, die deinem Pixel zugeordnet sind.
Mehr dazu erfährst du unter Nutzungssignale zu Produktkatalog zuordnen.

Beispiele

Ein Beispiel des Standard-Events Search ist unten aufgeführt. Wir empfehlen, dass du in content_ids 5 bis 10 Artikel aus der Liste deiner besten Suchergebnisse bereitstellst.

<!-- Facebook Pixel Code -->
<script>
!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
document,'script','https://connect.facebook.net/en_US/fbevents.js');
// Insert Your Facebook Pixel ID below. 
fbq('init', '<FB_PIXEL_ID>');
fbq('track', 'PageView');

fbq('track', 'Search', { 
  search_string: 'leather sandals',
  content_ids: ['1234', '2424', '1318', '6832'], // top 5-10 search results
  content_type: 'product'
});
</script>
<!-- End Facebook Pixel Code -->

Ein Beispiel eines ViewCategory-Events ist unten aufgeführt. Wir empfehlen, dass du 5 bis 10 Artikel in content_ids aus der Liste deiner besten Ergebnisse bereitstellst. Beachte, dass ViewCategory kein Standard-Event ist, deshalb wird die Funktion trackCustom eingesetzt.

<!-- Facebook Pixel Code -->
<script>
!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
document,'script','https://connect.facebook.net/en_US/fbevents.js');
// Insert Your Facebook Pixel ID below. 
fbq('init', '<FB_PIXEL_ID>');
fbq('track', 'PageView');

fbq('trackCustom', 'ViewCategory', {
  content_name: 'Really Fast Running Shoes',
  content_category: 'Apparel &amp; Accessories > Shoes',
  content_ids: ['1234', '2424', '1318', '6832'], // top 5-10 results
  content_type: 'product'
});
</script>
<!-- End Facebook Pixel Code -->

Ein Beispiel des Standard-Events Search ist unten aufgeführt. Weitere Informationen zur Pixel-Einrichtung findest du unter Meta-Pixel.

<!-- Facebook Pixel Code -->
<script>
!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
document,'script','https://connect.facebook.net/en_US/fbevents.js');
// Insert Your Facebook Pixel ID below. 
fbq('init', '<FB_PIXEL_ID>');
fbq('track', 'PageView');

fbq('track', 'ViewContent', {
  content_ids: ['1234'],
  content_type: 'product',
  value: 0.50,
  currency: 'USD'
});
</script>
<!-- End Facebook Pixel Code -->

Ein AddToCart-Standard-Event richtet sich danach, wie deine E-Commerce-Plattform mit dem Hinzufügen eines Artikels zum Einkaufswagen umgeht. Wenn der Vorgang dynamisch abläuft, sollte das Event in einem Event-Handler onclick platziert werden, damit es beim Klicken auf einen Button ausgelöst wird. Beim Laden einer neuen Seite kann das Pixel-Event wie ein normales Event feuern.

<!-- Facebook Pixel Code -->
<script>
!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
document,'script','https://connect.facebook.net/en_US/fbevents.js');
// Insert Your Facebook Pixel ID below. 
fbq('init', '<FB_PIXEL_ID>');
fbq('track', 'PageView');

// If you have a separate add to cart page that is loaded.
fbq('track', 'AddToCart', {
  content_ids: ['1234', '1853', '9386'],
  content_type: 'product',
  value: 3.50,
  currency: 'USD'
});
</script>
<!-- End Facebook Pixel Code -->

Wenn das Event beim Klicken auf einen Button feuern soll und es keine neue Seite gibt, die geladen wird:

<!-- The below method uses jQuery, but that is not required -->

<button id="addToCartButton">Add To Cart</button>
<!-- Add event to the button's click handler -->

<script type="text/javascript">
  $( '#addToCartButton' ).click(function() {
    fbq('track', 'AddToCart', {
      content_ids: ['1234'],
      content_type: 'product',
      value: 2.99,
      currency: 'USD' 
    });  
  });
</script>

Ein Purchase-Standard-Event mit zwei Artikeln unter Angabe von Menge:

<!-- Facebook Pixel Code -->
<script>
!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
document,'script','https://connect.facebook.net/en_US/fbevents.js');
// Insert Your Facebook Pixel ID below. 
fbq('init', '<FB_PIXEL_ID>');
fbq('track', 'PageView');

fbq('track', 'Purchase', {
  contents: [
    {'id': '1234', 'quantity': 2},
    {'id': '4642', 'quantity': 1}
  ],
  content_type: 'product',
  value: 21.97,
  currency: 'USD'
});
</script>

<!-- End Facebook Pixel Code -->

Ein Purchase-Standard-Event mit zwei Artikeln:

<!-- Facebook Pixel Code -->
<script>
!function(f,b,e,v,n,t,s){if(f.fbq)return;n=f.fbq=function(){n.callMethod?
n.callMethod.apply(n,arguments):n.queue.push(arguments)};if(!f._fbq)f._fbq=n;
n.push=n;n.loaded=!0;n.version='2.0';n.queue=[];t=b.createElement(e);t.async=!0;
t.src=v;s=b.getElementsByTagName(e)[0];s.parentNode.insertBefore(t,s)}(window,
document,'script','https://connect.facebook.net/en_US/fbevents.js');
// Insert Your Facebook Pixel ID below. 
fbq('init', '<FB_PIXEL_ID>');
fbq('track', 'PageView');

fbq('track', 'Purchase', {
  content_ids: ['1234', '4642'],
  content_type: 'product',
  value: 21.97,
  currency: 'USD'
});
</script>

<!-- End Facebook Pixel Code -->

Auswählen des richtigen content_type

Hinweis:fb_content_type ist der Inhaltstyp für Mobilgeräte.

Wenn auf der Seite eine bestimmte SKU aufgeführt ist (bestimmte Größe, Farbe usw.), dann verwende product als content_type und übergebe die Produkt-IDs (d. h. id-Spalte im Produkt-Feed) in content_ids. Alle AddToCart- und Purchase-Events sollten content_type=product verwenden, da Menschen nun einmal kein beliebiges Hemd in irgendeiner Größe und Farbe kaufen, sondern ein bestimmtes Hemd in einer bestimmten Größe und einer bestimmten Farbe.

Wenn auf der Seite eine bestimmte Gruppe ähnlicher Produkte aufgeführt ist, die sich durch die Größe, Farbe usw. unterscheiden, jedoch zu derselben Produktgruppe gehören, dann verwende product_group und übergebe die Produktgruppen-IDs (d. h. item_group_id-Spalte im Produkt-Feed) in content_ids. Ein häufiger Anwendungsfall ist eine ViewContent-Seite, auf der der*die Nutzer*in noch keine Größe ausgewählt hat. Verwende product_group nicht zusammen mit AddToCart oder Purchase.

Es ist wichtig, dass content_type mit dem Typ der ID oder der IDs im Parameter content_ids oder contents übereinstimmt.

Die Übergabe der spezifischen Produkt-IDs (content_type=product) ermöglicht Meta, relevantere Produkte zu empfehlen, da Facebook bekannt ist, für welche speziellen Varianten (Größe, Farbe usw.) sich der*die Nutzer*in interessiert. Wir zeigen immer Produkte (und keine Produktgruppen) an, sogar wenn content_type=product_group.

Wenn kein content_type angegeben wird, ordnet Meta das Event jedem Artikel mit derselben ID zu, unabhängig vom Typ. Das Senden von content_type wird empfohlen, da dir dies mehr Kontrolle darüber gibt, welche spezifische ID du im Event zuordnest.

Schritt 2: Nutzungssignale zu Produktkatalog zuordnen

Du musst deine Event-Quellen deinen Produktkatalogen zuweisen, damit Facebook diese Daten erfassen und in einer Anzeige das richtige Produkt abbilden kann. Besuche hierzu die Katalogseite des Business Manager und klicke auf den Button Associate Event Source. Wähle die App und das Pixel aus, die die Advantage+ Catalog Ad-Events empfangen werden.

Du kannst auch einen POST-API-Aufruf mit einer Liste externer Event-Quellen als UTF-8-codierte Abfrage-String-Parameter erstellen:

use FacebookAds\Object\ProductCatalog;

$product_catalog = new ProductCatalog(<PRODUCT_CATALOG_ID>);
$product_catalog->createExternalEventSource(array(), array(
  'external_event_sources' => array(
    <PIXEL_ID>,
    <APP_ID>,
  ),
));
from facebookads.adobjects.productcatalog import ProductCatalog

product_catalog = ProductCatalog(<PRODUCT_CATALOG_ID>)
product_catalog.add_external_event_sources([
    <PIXEL_ID>,
    <APP_ID>,
])
curl \
  -F 'external_event_sources=["<PIXEL_ID>","<APP_ID>"]' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<PRODUCT_CATALOG_ID>/external_event_sources

Hinweis: Du benötigst Berechtigungen für den Katalog, das Pixel und die App sowie für das Unternehmen.

Parameter

NameBeschreibung

external_event_sources

Erforderlich.
Ein Array von App und Pixel-IDs für das Zuordnen, als UTF-8-codierte Abfrage-String-Parameter.

Schritt 3: Produktzielgruppen erstellen

Im nächsten Schritt erstellst du Produktzielgruppen basierend auf Aktivitäten in deinen mobilen Apps und auf deiner Website. Du kannst angeben, welche Events verwendet werden sollen, und Werbeanzeigen mit deinen Produktzielgruppen gezielt schalten.

Bei Standard-App-Events wird die Zielgruppe unter den Event-Namen der Pixel mit Werbeanzeigen zusammengefasst:

  • Search
  • ViewContent
  • AddToCart
  • Purchase

Verwende diese Event-Namen in deinen Zielgruppenregeln, auch wenn hierbei Nutzer*innen von Android und iOS eingeschlossen werden.

Erstelle eine Produktzielgruppe, indem du einen POST-Aufruf an den /act_{ad-account-id}/product_audiences-Endpunkt sendest.

https://graph.facebook.com/v21.0/act_AD_ACCOUNT_ID/product_audiences

Parameter

NameBeschreibung

name

String

Erforderlich.
Der Name der Zielgruppe.

description

String

Optional.
Eine Beschreibung der Zielgruppe.

product_set_id

Numerischer String

Erforderlich. Die Produktpalette, mit der du dich an diese Zielgruppe richten möchtest.

inclusions

JSON-Objekt

Erforderlich.
Eine Reihe von Events, auf die du abzielen möchtest. Es ist mindestens ein Einschluss erforderlich. Jeder Einschluss sollte aus genau einem Event bestehen.

inclusions.retention_seconds

Int

Erforderlich.
Die Anzahl der Sekunden, die das Konto der Kontenübersicht in der Zielgruppe gehalten werden soll.

inclusions.rule

object[]

Erforderlich.
Regel für Website Custom Audience mit Bezug auf ein event.

exclusions

JSON-Objekt

Optional.
Events, bei denen ein Konto der Kontenübersicht vom Targeting ausgeschlossen werden soll.
Im Falle von Ausschlüssen wird ein Konto der Kontenübersicht mit diesen Events vom Targeting ausgeschlossen, wenn das Event für ein beliebiges Produkt in derselben Produktgruppe (d. h. Produkte, die im Produkt-Feed dieselbe item_group_id in aufweisen) eingetreten ist.
Beispiel: Die Produktzielgruppe wird so eingestellt, dass sie das Event ViewContent einschließt und das Event „Kauf“ ausschließt. Ein Konto der Kontenübersicht zeigt Produkt A und B an und kauft Produkt B. Wenn Produkt A und Produkt B zur selben Produktgruppe gehören, wird dieses Konto der Kontenübersicht aus der Produktzielgruppe ausgeschlossen, da es sich bei A und B um Varianten handelt. Wenn Produkt A und B nicht zur selben Produktgruppe gehören, bleibt das Konto der Kontenübersicht weiterhin in der Zielgruppe, da sie noch immer über ein ViewContent-Event für Produkt A verfügt.

exclusions.retention_seconds

Int

Erforderlich, wenn ein Ausschluss festgelegt wird.
Die Anzahl der Sekunden, die der Ausschluss beibehalten wird.

exclusions.rule

object[]

Erforderlich, wenn ein Ausschluss festgelegt wird.
Regel für Website Custom Audience mit Bezug auf ein event.

Jede Regel muss ein event mit dem Operator eq entweder als übergeordnete Regel oder als Teil einer übergeordneten and-Regel enthalten.

Bei Verwendung desselben event in Einschlüssen und Ausschlüssen müssen alle zusätzlichen Parameterprüfungen genau gleich sein.

Beispiele

Erstelle beispielsweise für das Targeting von Personen, die Produkte angezeigt oder zum Einkaufwagen hinzugefügt, sie aber nicht gekauft haben, folgende Zielgruppe:

curl -X POST \
  -F 'name="Test Product Audience"' \
  -F 'product_set_id="<PRODUCT_SET_ID>"' \
  -F 'inclusions=[
       {
         "retention_seconds": 86400,
         "rule": {
           "event": {
             "eq": "AddToCart"
           }
         }
       },
       {
         "retention_seconds": 72000,
         "rule": {
           "event": {
             "eq": "ViewContent"
           }
         }
       }
     ]' \
  -F 'exclusions=[
       {
         "retention_seconds": 172800,
         "rule": {
           "event": {
             "eq": "Purchase"
           }
         }
       }
     ]' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v21.0/act_<AD_ACCOUNT_ID>/product_audiences
Open In Graph API Explorer
'use strict';
const bizSdk = require('facebook-nodejs-business-sdk');
const AdAccount = bizSdk.AdAccount;
const CustomAudience = bizSdk.CustomAudience;

const access_token = '<ACCESS_TOKEN>';
const app_secret = '<APP_SECRET>';
const app_id = '<APP_ID>';
const id = '<AD_ACCOUNT_ID>';
const api = bizSdk.FacebookAdsApi.init(access_token);
const showDebugingInfo = true; // Setting this to true shows more debugging info.
if (showDebugingInfo) {
  api.setDebug(true);
}

const logApiCallResult = (apiCallName, data) => {
  console.log(apiCallName);
  if (showDebugingInfo) {
    console.log('Data:' + JSON.stringify(data));
  }
};

let fields, params;
fields = [
];
params = {
  'name' : 'Test Product Audience',
  'product_set_id' : '<productSetID>',
  'inclusions' : [{'retention_seconds':86400,'rule':{'event':{'eq':'AddToCart'}}},{'retention_seconds':72000,'rule':{'event':{'eq':'ViewContent'}}}],
  'exclusions' : [{'retention_seconds':172800,'rule':{'event':{'eq':'Purchase'}}}],
};
const product_audiences = (new AdAccount(id)).createProductAudience(
  fields,
  params
);
logApiCallResult('product_audiences api call complete.', product_audiences);
Open In Graph API Explorer
require __DIR__ . '/vendor/autoload.php';

use FacebookAds\Object\AdAccount;
use FacebookAds\Object\CustomAudience;
use FacebookAds\Api;
use FacebookAds\Logger\CurlLogger;

$access_token = '<ACCESS_TOKEN>';
$app_secret = '<APP_SECRET>';
$app_id = '<APP_ID>';
$id = '<AD_ACCOUNT_ID>';

$api = Api::init($app_id, $app_secret, $access_token);
$api->setLogger(new CurlLogger());

$fields = array(
);
$params = array(
  'name' => 'Test Product Audience',
  'product_set_id' => '<productSetID>',
  'inclusions' => array(array('retention_seconds' => 86400,'rule' => array('event' => array('eq' => 'AddToCart'))),array('retention_seconds' => 72000,'rule' => array('event' => array('eq' => 'ViewContent')))),
  'exclusions' => array(array('retention_seconds' => 172800,'rule' => array('event' => array('eq' => 'Purchase')))),
);
echo json_encode((new AdAccount($id))->createProductAudience(
  $fields,
  $params
)->exportAllData(), JSON_PRETTY_PRINT);
Open In Graph API Explorer
from facebook_business.adobjects.adaccount import AdAccount
from facebook_business.adobjects.customaudience import CustomAudience
from facebook_business.api import FacebookAdsApi

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'
FacebookAdsApi.init(access_token=access_token)

fields = [
]
params = {
  'name': 'Test Product Audience',
  'product_set_id': '<productSetID>',
  'inclusions': [{'retention_seconds':86400,'rule':{'event':{'eq':'AddToCart'}}},{'retention_seconds':72000,'rule':{'event':{'eq':'ViewContent'}}}],
  'exclusions': [{'retention_seconds':172800,'rule':{'event':{'eq':'Purchase'}}}],
}
print AdAccount(id).create_product_audience(
  fields=fields,
  params=params,
)
Open In Graph API Explorer
import com.facebook.ads.sdk.*;
import java.io.File;
import java.util.Arrays;

public class SAMPLE_CODE_EXAMPLE {
  public static void main (String args[]) throws APIException {

    String access_token = \"<ACCESS_TOKEN>\";
    String app_secret = \"<APP_SECRET>\";
    String app_id = \"<APP_ID>\";
    String id = \"<AD_ACCOUNT_ID>\";
    APIContext context = new APIContext(access_token).enableDebug(true);

    new AdAccount(id, context).createProductAudience()
      .setName(\"Test Product Audience\")
      .setProductSetId(\"<productSetID>\")
      .setInclusions(\"[{\\"retention_seconds\\":86400,\\"rule\\":{\\"event\\":{\\"eq\\":\\"AddToCart\\"}}},{\\"retention_seconds\\":72000,\\"rule\\":{\\"event\\":{\\"eq\\":\\"ViewContent\\"}}}]\")
      .setExclusions(\"[{\\"retention_seconds\\":172800,\\"rule\\":{\\"event\\":{\\"eq\\":\\"Purchase\\"}}}]\")
      .execute();

  }
}
Open In Graph API Explorer
require 'facebook_ads'

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'

FacebookAds.configure do |config|
  config.access_token = access_token
  config.app_secret = app_secret
end

ad_account = FacebookAds::AdAccount.get(id)
product_audiences = ad_account.product_audiences.create({
    name: 'Test Product Audience',
    product_set_id: '<productSetID>',
    inclusions: [{'retention_seconds':86400,'rule':{'event':{'eq':'AddToCart'}}},{'retention_seconds':72000,'rule':{'event':{'eq':'ViewContent'}}}],
    exclusions: [{'retention_seconds':172800,'rule':{'event':{'eq':'Purchase'}}}],
})
Open In Graph API Explorer

Wenn du deine Anzeigen an Personen richten möchtest, die ein Produkt im Web über ihr iPhone angezeigt, es jedoch auf keinem Gerät gekauft haben, erstelle die folgende Zielgruppe.

Dies setzt voraus, dass du einen userAgent-Parameter in deinen Meta-Pixel einfügst.

curl -X POST \
  -F 'name="Test Iphone Product Audience"' \
  -F 'product_set_id="<PRODUCT_SET_ID>"' \
  -F 'inclusions=[
       {
         "retention_seconds": 86400,
         "rule": {
           "and": [
             {
               "event": {
                 "eq": "AddToCart"
               }
             },
             {
               "userAgent": {
                 "i_contains": "iPhone"
               }
             }
           ]
         }
       }
     ]' \
  -F 'exclusions=[
       {
         "retention_seconds": 172800,
         "rule": {
           "event": {
             "eq": "Purchase"
           }
         }
       }
     ]' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v21.0/act_<AD_ACCOUNT_ID>/product_audiences
Open In Graph API Explorer
'use strict';
const bizSdk = require('facebook-nodejs-business-sdk');
const AdAccount = bizSdk.AdAccount;
const CustomAudience = bizSdk.CustomAudience;

const access_token = '<ACCESS_TOKEN>';
const app_secret = '<APP_SECRET>';
const app_id = '<APP_ID>';
const id = '<AD_ACCOUNT_ID>';
const api = bizSdk.FacebookAdsApi.init(access_token);
const showDebugingInfo = true; // Setting this to true shows more debugging info.
if (showDebugingInfo) {
  api.setDebug(true);
}

const logApiCallResult = (apiCallName, data) => {
  console.log(apiCallName);
  if (showDebugingInfo) {
    console.log('Data:' + JSON.stringify(data));
  }
};

let fields, params;
fields = [
];
params = {
  'name' : 'Test Iphone Product Audience',
  'product_set_id' : '<productSetID>',
  'inclusions' : [{'retention_seconds':86400,'rule':{'and':[{'event':{'eq':'AddToCart'}},{'userAgent':{'i_contains':'iPhone'}}]}}],
  'exclusions' : [{'retention_seconds':172800,'rule':{'event':{'eq':'Purchase'}}}],
};
const product_audiences = (new AdAccount(id)).createProductAudience(
  fields,
  params
);
logApiCallResult('product_audiences api call complete.', product_audiences);
Open In Graph API Explorer
require __DIR__ . '/vendor/autoload.php';

use FacebookAds\Object\AdAccount;
use FacebookAds\Object\CustomAudience;
use FacebookAds\Api;
use FacebookAds\Logger\CurlLogger;

$access_token = '<ACCESS_TOKEN>';
$app_secret = '<APP_SECRET>';
$app_id = '<APP_ID>';
$id = '<AD_ACCOUNT_ID>';

$api = Api::init($app_id, $app_secret, $access_token);
$api->setLogger(new CurlLogger());

$fields = array(
);
$params = array(
  'name' => 'Test Iphone Product Audience',
  'product_set_id' => '<productSetID>',
  'inclusions' => array(array('retention_seconds' => 86400,'rule' => array('and' => array(array('event' => array('eq' => 'AddToCart')),array('userAgent' => array('i_contains' => 'iPhone')))))),
  'exclusions' => array(array('retention_seconds' => 172800,'rule' => array('event' => array('eq' => 'Purchase')))),
);
echo json_encode((new AdAccount($id))->createProductAudience(
  $fields,
  $params
)->exportAllData(), JSON_PRETTY_PRINT);
Open In Graph API Explorer
from facebook_business.adobjects.adaccount import AdAccount
from facebook_business.adobjects.customaudience import CustomAudience
from facebook_business.api import FacebookAdsApi

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'
FacebookAdsApi.init(access_token=access_token)

fields = [
]
params = {
  'name': 'Test Iphone Product Audience',
  'product_set_id': '<productSetID>',
  'inclusions': [{'retention_seconds':86400,'rule':{'and':[{'event':{'eq':'AddToCart'}},{'userAgent':{'i_contains':'iPhone'}}]}}],
  'exclusions': [{'retention_seconds':172800,'rule':{'event':{'eq':'Purchase'}}}],
}
print AdAccount(id).create_product_audience(
  fields=fields,
  params=params,
)
Open In Graph API Explorer
import com.facebook.ads.sdk.*;
import java.io.File;
import java.util.Arrays;

public class SAMPLE_CODE_EXAMPLE {
  public static void main (String args[]) throws APIException {

    String access_token = \"<ACCESS_TOKEN>\";
    String app_secret = \"<APP_SECRET>\";
    String app_id = \"<APP_ID>\";
    String id = \"<AD_ACCOUNT_ID>\";
    APIContext context = new APIContext(access_token).enableDebug(true);

    new AdAccount(id, context).createProductAudience()
      .setName(\"Test Iphone Product Audience\")
      .setProductSetId(\"<productSetID>\")
      .setInclusions(\"[{\\"retention_seconds\\":86400,\\"rule\\":{\\"and\\":[{\\"event\\":{\\"eq\\":\\"AddToCart\\"}},{\\"userAgent\\":{\\"i_contains\\":\\"iPhone\\"}}]}}]\")
      .setExclusions(\"[{\\"retention_seconds\\":172800,\\"rule\\":{\\"event\\":{\\"eq\\":\\"Purchase\\"}}}]\")
      .execute();

  }
}
Open In Graph API Explorer
require 'facebook_ads'

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'

FacebookAds.configure do |config|
  config.access_token = access_token
  config.app_secret = app_secret
end

ad_account = FacebookAds::AdAccount.get(id)
product_audiences = ad_account.product_audiences.create({
    name: 'Test Iphone Product Audience',
    product_set_id: '<productSetID>',
    inclusions: [{'retention_seconds':86400,'rule':{'and':[{'event':{'eq':'AddToCart'}},{'userAgent':{'i_contains':'iPhone'}}]}}],
    exclusions: [{'retention_seconds':172800,'rule':{'event':{'eq':'Purchase'}}}],
})
Open In Graph API Explorer

Abrufen von Produktzielgruppen

Sobald du eine Produktzielgruppe erstellt hast, kannst du sie über die Custom Audiences API abrufen. Du kannst die ursprünglich für die Erstellung von Zielgruppen verwendeten Parameter über den Parameter data_source abrufen.

Eine Produktzielgruppe ist eine spezielle Art von Custom Audience, die von Produkt-Events dynamisch erstellt wird. Der Endpunkt act_{ad-account-id}/product_audiences ist ein spezieller POST-Endpunkt zur Erstellung dieser Zielgruppen.

Beispiele

So rufst du eine Custom Audience ab:

curl -X GET \
  -d 'fields="data_source,subtype"' \
  -d 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v21.0/act_<AD_ACCOUNT_ID>/customaudiences
Open In Graph API Explorer
'use strict';
const bizSdk = require('facebook-nodejs-business-sdk');
const AdAccount = bizSdk.AdAccount;
const CustomAudience = bizSdk.CustomAudience;

const access_token = '<ACCESS_TOKEN>';
const app_secret = '<APP_SECRET>';
const app_id = '<APP_ID>';
const id = '<AD_ACCOUNT_ID>';
const api = bizSdk.FacebookAdsApi.init(access_token);
const showDebugingInfo = true; // Setting this to true shows more debugging info.
if (showDebugingInfo) {
  api.setDebug(true);
}

const logApiCallResult = (apiCallName, data) => {
  console.log(apiCallName);
  if (showDebugingInfo) {
    console.log('Data:' + JSON.stringify(data));
  }
};

let fields, params;
fields = [
  'data_source',
  'subtype',
];
params = {
};
const customaudiencess = (new AdAccount(id)).getCustomAudiences(
  fields,
  params
);
logApiCallResult('customaudiencess api call complete.', customaudiencess);
Open In Graph API Explorer
require __DIR__ . '/vendor/autoload.php';

use FacebookAds\Object\AdAccount;
use FacebookAds\Object\CustomAudience;
use FacebookAds\Api;
use FacebookAds\Logger\CurlLogger;

$access_token = '<ACCESS_TOKEN>';
$app_secret = '<APP_SECRET>';
$app_id = '<APP_ID>';
$id = '<AD_ACCOUNT_ID>';

$api = Api::init($app_id, $app_secret, $access_token);
$api->setLogger(new CurlLogger());

$fields = array(
  'data_source',
  'subtype',
);
$params = array(
);
echo json_encode((new AdAccount($id))->getCustomAudiences(
  $fields,
  $params
)->getResponse()->getContent(), JSON_PRETTY_PRINT);
Open In Graph API Explorer
from facebook_business.adobjects.adaccount import AdAccount
from facebook_business.adobjects.customaudience import CustomAudience
from facebook_business.api import FacebookAdsApi

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'
FacebookAdsApi.init(access_token=access_token)

fields = [
  'data_source',
  'subtype',
]
params = {
}
print AdAccount(id).get_custom_audiences(
  fields=fields,
  params=params,
)
Open In Graph API Explorer
import com.facebook.ads.sdk.*;
import java.io.File;
import java.util.Arrays;

public class SAMPLE_CODE_EXAMPLE {
  public static void main (String args[]) throws APIException {

    String access_token = \"<ACCESS_TOKEN>\";
    String app_secret = \"<APP_SECRET>\";
    String app_id = \"<APP_ID>\";
    String id = \"<AD_ACCOUNT_ID>\";
    APIContext context = new APIContext(access_token).enableDebug(true);

    new AdAccount(id, context).getCustomAudiences()
      .requestField(\"data_source\")
      .requestField(\"subtype\")
      .execute();

  }
}
Open In Graph API Explorer
require 'facebook_ads'

access_token = '<ACCESS_TOKEN>'
app_secret = '<APP_SECRET>'
app_id = '<APP_ID>'
id = '<AD_ACCOUNT_ID>'

FacebookAds.configure do |config|
  config.access_token = access_token
  config.app_secret = app_secret
end

ad_account = FacebookAds::AdAccount.get(id)
customaudiencess = ad_account.customaudiences({
    fields: { 'data_source''subtype' },
})
Open In Graph API Explorer

So rufst du eine bestimmte Produktzielgruppe ab:

use FacebookAds\Object\ProductAudience;

$product_audience = new ProductAudience(<PRODUCT_AUDIENCE_ID>);
$product_audience->read();
from facebookads.objects import ProductAudience

product_audience = ProductAudience(<PRODUCT_AUDIENCE_ID>)
product_audience.remote_read()
CustomAudience customAudience2 = new CustomAudience(<PRODUCT_AUDIENCE_ID>, context).get()
  .execute();
curl -G \
  -d 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<PRODUCT_AUDIENCE_ID>

Mehr dazu