Verwenden der API

Sobald du die Voraussetzungen auf der Seite Erste Schritte erfüllt hast, kannst du diese Seite verwenden, um zu erfahren, wie du Events sendest und das Tool „Test-Events“ verwendest. Sobald du ein Event gesendet hast, solltest du dein Setup verifizieren.

Die Conversions API basiert auf der Facebook Marketing API, die wiederum auf unserer Graph API aufsetzt. Die Marketing und die Graph API haben unterschiedliche Zeitpläne im Hinblick auf die Veraltung von Versionen. Unser Versionszyklus orientiert sich an der Graph API, daher wird jede Version mindestens zwei Jahre unterstützt. Diese Ausnahme gilt nur für die Conversions API.

Anfragen senden

Um neue Events zu senden, erstelle eine POST-Anfrage an die /events-Edge dieser API von diesem Pfad aus: https://graph.facebook.com/{API_VERSION}/{PIXEL_ID}/events?access_token={TOKEN}. Wenn du in dieser Edge postest, erstellt Facebook neue Server-Events.

curl -X POST \
  -F 'data=[
       {
         "event_name": "Purchase",
         "event_time": 1715940685,
         "user_data": {
           "em": [
             "309a0a5c3e211326ae75ca18196d301a9bdbd1a882a4d2569511033da23f0abd"
           ],
           "ph": [
             "254aa248acb47dd654ca3ea53f48c2c26d641d23d7e2e93a1ec56258df7674c4",
             "6f4fcb9deaeadc8f9746ae76d97ce1239e98b404efe5da3ee0b7149740f89ad6"
           ],
           "client_ip_address": "123.123.123.123",
           "client_user_agent": "$CLIENT_USER_AGENT",
           "fbc": "fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890",
           "fbp": "fb.1.1558571054389.1098115397"
         },
         "custom_data": {
           "currency": "usd",
           "value": 123.45,
           "contents": [
             {
               "id": "product123",
               "quantity": 1,
               "delivery_category": "home_delivery"
             }
           ]
         },
         "event_source_url": "http://jaspers-market.com/product/123",
         "action_source": "website"
       }
     ]' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v19.0/<PIXEL_ID>/events

'use strict';
const bizSdk = require('facebook-nodejs-business-sdk');
const Content = bizSdk.Content;
const CustomData = bizSdk.CustomData;
const DeliveryCategory = bizSdk.DeliveryCategory;
const EventRequest = bizSdk.EventRequest;
const UserData = bizSdk.UserData;
const ServerEvent = bizSdk.ServerEvent;

const access_token = '<ACCESS_TOKEN>';
const pixel_id = '<ADS_PIXEL_ID>';
const api = bizSdk.FacebookAdsApi.init(access_token);

let current_timestamp = Math.floor(new Date() / 1000);

const userData = (new UserData())
                .setEmails(['joe@eg.com'])
                .setPhones(['12345678901', '14251234567'])
                // It is recommended to send Client IP and User Agent for Conversions API Events.
                .setClientIpAddress(request.connection.remoteAddress)
                .setClientUserAgent(request.headers['user-agent'])
                .setFbp('fb.1.1558571054389.1098115397')
                .setFbc('fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890');

const content = (new Content())
                .setId('product123')
                .setQuantity(1)
                .setDeliveryCategory(DeliveryCategory.HOME_DELIVERY);

const customData = (new CustomData())
                .setContents([content])
                .setCurrency('usd')
                .setValue(123.45);

const serverEvent = (new ServerEvent())
                .setEventName('Purchase')
                .setEventTime(current_timestamp)
                .setUserData(userData)
                .setCustomData(customData)
                .setEventSourceUrl('http://jaspers-market.com/product/123')
                .setActionSource('website');

const eventsData = [serverEvent];
const eventRequest = (new EventRequest(access_token, pixel_id))
                .setEvents(eventsData);

eventRequest.execute().then(
  response => {
    console.log('Response: ', response);
  },
  err => {
    console.error('Error: ', err);
  }
);

require __DIR__ . '/vendor/autoload.php';

use FacebookAds\Api;
use FacebookAds\Logger\CurlLogger;
use FacebookAds\Object\ServerSide\ActionSource;
use FacebookAds\Object\ServerSide\Content;
use FacebookAds\Object\ServerSide\CustomData;
use FacebookAds\Object\ServerSide\DeliveryCategory;
use FacebookAds\Object\ServerSide\Event;
use FacebookAds\Object\ServerSide\EventRequest;
use FacebookAds\Object\ServerSide\UserData;

$access_token = '<ACCESS_TOKEN>';
$pixel_id = '<ADS_PIXEL_ID>';

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

$user_data = (new UserData())
    ->setEmails(array('joe@eg.com'))
    ->setPhones(array('12345678901', '14251234567'))
    // It is recommended to send Client IP and User Agent for Conversions API Events.
    ->setClientIpAddress($_SERVER['REMOTE_ADDR'])
    ->setClientUserAgent($_SERVER['HTTP_USER_AGENT'])
    ->setFbc('fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890')
    ->setFbp('fb.1.1558571054389.1098115397');

$content = (new Content())
    ->setProductId('product123')
    ->setQuantity(1)
    ->setDeliveryCategory(DeliveryCategory::HOME_DELIVERY);

$custom_data = (new CustomData())
    ->setContents(array($content))
    ->setCurrency('usd')
    ->setValue(123.45);

$event = (new Event())
    ->setEventName('Purchase')
    ->setEventTime(time())
    ->setEventSourceUrl('http://jaspers-market.com/product/123')
    ->setUserData($user_data)
    ->setCustomData($custom_data)
    ->setActionSource(ActionSource::WEBSITE);

$events = array();
array_push($events, $event);

$request = (new EventRequest($pixel_id))
    ->setEvents($events);
$response = $request->execute();
print_r($response);

import time

from facebook_business.adobjects.serverside.action_source import ActionSource
from facebook_business.adobjects.serverside.content import Content
from facebook_business.adobjects.serverside.custom_data import CustomData
from facebook_business.adobjects.serverside.delivery_category import DeliveryCategory
from facebook_business.adobjects.serverside.event import Event
from facebook_business.adobjects.serverside.event_request import EventRequest
from facebook_business.adobjects.serverside.user_data import UserData
from facebook_business.api import FacebookAdsApi

access_token = '<ACCESS_TOKEN>'
pixel_id = 'ADS_PIXEL_ID>'

FacebookAdsApi.init(access_token=access_token)

user_data = UserData(
    emails=['joe@eg.com'],
    phones=['12345678901', '14251234567'],
    # It is recommended to send Client IP and User Agent for Conversions API Events.
    client_ip_address=request.META.get('REMOTE_ADDR'),
    client_user_agent=request.headers['User-Agent'],
    fbc='fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890',
    fbp='fb.1.1558571054389.1098115397',
)

content = Content(
    product_id='product123',
    quantity=1,
    delivery_category=DeliveryCategory.HOME_DELIVERY,
)

custom_data = CustomData(
    contents=[content],
    currency='usd',
    value=123.45,
)

event = Event(
    event_name='Purchase',
    event_time=int(time.time()),
    user_data=user_data,
    custom_data=custom_data,
    event_source_url='http://jaspers-market.com/product/123',
    action_source=ActionSource.WEBSITE,
)

events = [event]

event_request = EventRequest(
    events=events,
    pixel_id=pixel_id,
)

event_response = event_request.execute()
print(event_response)

import com.facebook.ads.sdk.APIContext;
import com.facebook.ads.sdk.APIException;
import com.facebook.ads.sdk.serverside.ActionSource;
import com.facebook.ads.sdk.serverside.Content;
import com.facebook.ads.sdk.serverside.CustomData;
import com.facebook.ads.sdk.serverside.DeliveryCategory;
import com.facebook.ads.sdk.serverside.Event;
import com.facebook.ads.sdk.serverside.EventRequest;
import com.facebook.ads.sdk.serverside.EventResponse;
import com.facebook.ads.sdk.serverside.UserData;

import java.util.Arrays;

public class ServerSideApiExample {

  public static final String ACCESS_TOKEN = "<ACCESS_TOKEN>";
  public static final String PIXEL_ID = "<ADS_PIXEL_ID>";

  public static void main(String[] args) {
    APIContext context = new APIContext(ACCESS_TOKEN).enableDebug(true);
    context.setLogger(System.out);

    UserData userData = new UserData()
        .emails(Arrays.asList("joe@eg.com"))
        .phones(Arrays.asList("12345678901", "14251234567"))
        // It is recommended to send Client IP and User Agent for Conversions API Events.
        .clientIpAddress(clientIpAddress)
        .clientUserAgent(clientUserAgent)
        .fbc("fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890")
        .fbp("fb.1.1558571054389.1098115397");

    Content content = new Content()
        .productId("product123")
        .quantity(1L)
        .deliveryCategory(DeliveryCategory.home_delivery);

    CustomData customData = new CustomData()
        .addContent(content)
        .currency("usd")
        .value(123.45F);

    Event purchaseEvent = new Event();
    purchaseEvent.eventName("Purchase")
        .eventTime(System.currentTimeMillis() / 1000L)
        .userData(userData)
        .customData(customData)
        .eventSourceUrl("http://jaspers-market.com/product/123")
        .actionSource(ActionSource.website);

    EventRequest eventRequest = new EventRequest(PIXEL_ID, context);
    eventRequest.addDataItem(purchaseEvent);

    try {
      EventResponse response = eventRequest.execute();
      System.out.println(String.format("Standard API response : %s ", response));
    } catch (APIException e) {
      e.printStackTrace();
    }
  }
}

require 'facebook_ads'

access_token = '<ACCESS_TOKEN>'
pixel_id = '<ADS_PIXEL_ID>'

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

user_data = FacebookAds::ServerSide::UserData.new(
    emails: ['joe@eg.com'],
    phones: ['12345678901', '14251234567'],
    # It is recommended to send Client IP and User Agent for Conversions API Events.
    client_ip_address: request.remote_ip,
    client_user_agent: request.user_agent,
    fbc: 'fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890',
    fbp: 'fb.1.1558571054389.1098115397'
)

content = FacebookAds::ServerSide::Content.new(
    product_id: 'product123',
    quantity: 1,
    delivery_category: 'home_delivery'
)

custom_data = FacebookAds::ServerSide::CustomData.new(
    contents: [content],
    currency: 'usd',
    value: 123.45
)

event = FacebookAds::ServerSide::Event.new(
    event_name: 'Purchase',
    event_time: Time.now.to_i,
    user_data: user_data,
    custom_data: custom_data,
    event_source_url: 'http://jaspers-market.com/product/123',
    action_source: 'website'
)

request = FacebookAds::ServerSide::EventRequest.new(
    pixel_id: pixel_id,
    events: [event]
)

print request.execute

Hänge deinen generierten sicheren Zugriffsschlüssel mit dem Abfrageparameter access_token an die Anfrage an. Du kannst auch mit Graph API Explorer eine POST-Anfrage an den Endpunkt /<pixel_id>/events senden.

Ein Beispiel für eine Anfrage sieht folgendermaßen aus:

{
   "data": [
      {
         "event_name": "Purchase",
         "event_time": 1633552688,
         "event_id": "event.id.123",
         "event_source_url": "http:\/\/jaspers-market.com\/product\/123",         
         "action_source": "website",
         "user_data": {
            "client_ip_address": "192.19.9.9",
            "client_user_agent": "test ua",
            "em": [
               "309a0a5c3e211326ae75ca18196d301a9bdbd1a882a4d2569511033da23f0abd"
            ],
            "ph": [
               "254aa248acb47dd654ca3ea53f48c2c26d641d23d7e2e93a1ec56258df7674c4",
               "6f4fcb9deaeadc8f9746ae76d97ce1239e98b404efe5da3ee0b7149740f89ad6"
            ],
            "fbc": "fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890",
            "fbp": "fb.1.1558571054389.1098115397"
         },
         "custom_data": {
            "value": 100.2,
            "currency": "USD",
            "content_ids": [
               "product.id.123"
            ],
            "content_type": "product"
         },
         "opt_out": false
      },
      {
         "event_name": "Purchase",
         "event_time": 1633552688,
         "user_data": {
            "client_ip_address": "192.88.9.9",
            "client_user_agent": "test ua2"
         },
         "custom_data": {
            "value": 50.5,
            "currency": "USD"
         },
         "opt_out": false
      }
   ]
}

Upload-Zeit im Vergleich zur Event-Transaktionszeit

event_time ist die Event-Transaktionszeit. Sie sollte als UNIX-Zeitstempel in Sekunden gesendet werden und angeben, wann das tatsächliche Event stattgefunden hat. Die angegebene Uhrzeit kann vor der Zeit liegen, zu der du das Event an Facebook gesendet hast. Das ermöglicht Batch-Verarbeitung und Optimierung der Serverleistung.

event_time kann bis zu 7 Tage vor dem Zeitpunkt liegen, zu dem du ein Event an Meta gesendet hast. Liegt eine event_time in data weiter als 7 Tage zurück, geben wir einen Fehler für die gesamte Anfrage zurück und verarbeiten keine Events. Bei Offline-Events und Events in physischen Geschäften mit physical_store als action_source solltest du Transaktionen innerhalb von 62 Tagen nach der Conversion hochladen.

Batch-Anfragen

Du kannst bis zu 1.000 Events in data senden. Für eine optimale Leistung empfehlen wir dir jedoch, Events sofort bei Auftreten und idealerweise innerhalb von einer Stunde nach dem Event-Zeitpunkt zu senden. Ist eines der Events, die du in einem Batch sendest, ungültig, lehnen wir den gesamten Batch ab.

Hashing

Auf unserer Seite Parameter für Kund*inneninformationen erfährst du, welche Parameter vor dem Senden an Facebook gehasht werden müssen. Wenn du eines unserer Business SDKs verwendest, übernimmt das SDK das erforderliche Hashing.

Funktionen des Business SDK für die Conversions API

Erfahre mehr über drei bestimmte Funktionen des Business SDK, die speziell für Nutzer*innen der Conversions API entwickelt wurden: Asynchrone Anfragen, gleichzeitiges Batching und HTTP-Serviceschnittstelle. Für die Verwendung dieser Funktionen erforderliche Mindestversion der Programmiersprache:

• PHP >= 7.2
• Node.js >= 7.6.0
• Java >= 8
• Python >= 2.7
• Ruby >= 2

Events verifizieren

Nach dem Senden deiner Events kannst du im Events Manager verifizieren, ob wir sie erhalten haben:

• Klicke auf der Seite Datenquellen auf das entsprechende Pixel für die PIXEL_ID in deiner POST-Anfrage. Weitere Informationen findest du unter Hilfebereich für Unternehmen: Im Events Manager navigieren.
• Klicke dann auf Übersicht. Hier findest du die Anzahl ursprünglicher sowie ermittelter und zugeordneter Events, die wir erhalten haben. Unter Verbindungsmethode wird der Kanal angezeigt, über den das betreffende Event gesendet wurde.

• Du kannst auf jedes Event klicken, um spezifischere Informationen zu erhalten.

• Nachdem du begonnen hast, Events zu senden, solltest du in der Lage sein, diese innerhalb von 20 Minuten zu verifizieren. Nun kannst du damit beginnen, Events von deinem Server zu senden.

Tool zum Testen von Events

Mit der Funktion „Test-Events“ im Events Manager kannst du verifizieren, ob deine Server-Events richtig von Facebook empfangen werden. Du findest das Tool unter Events Manager > Data Sources > Your Pixel > Test Events.

Das Tool „Test-Events“ generiert eine Test-ID. Sende die Test-ID als test_event_code-Parameter, um Event-Aktivitäten im Fenster „Test-Events“ anzuzeigen.

Siehe hier ein Beispiel für die Strukturierung der Anfrage:

{
   "data": [
      {
         "event_name": "ViewContent",
         "event_time": 1715940085,
         "event_id": "event.id.123",
         "event_source_url": "http:\/\/jaspers-market.com",
         "user_data": {
            "client_ip_address": "1.2.3.4",
            "client_user_agent": "test user agent"
         }
      }
   ],
   "test_event_code": "TEST123"
}

Hier siehst du ein Beispiel für die Anzeige der Anfrage in Graph API Explorer:

Deine Server-Events werden im Fenster „Test-Events“ angezeigt, sobald die Anfrage gesendet wurde.

Datenverarbeitungsoptionen für Nutzer*innen in den USA

{
    "data": [
        {
            "event_name": "Purchase",
            "event_time": <EVENT_TIME>,
            "user_data": {
                "em": "<EMAIL>"
            },
            "custom_data": {
                "currency": "<CURRENCY>",
                "value": "<VALUE>"
            },
            "data_processing_options": []
        }
    ]
}

{
    "data": [
        {
            "event_name": "Purchase",
            "event_time": <EVENT_TIME>,
            "user_data": {
                "em": "<EMAIL>",
                "client_ip_address": "256.256.256.256"
            },
            "custom_data": {
                "currency": "<CURRENCY>",
                "value": "<VALUE>"
            },
            "data_processing_options": ["LDU"],
            "data_processing_options_country": 0,
            "data_processing_options_state": 0
        }
    ]
}

{
    "data": [
        {
            "event_name": "Purchase",
            "event_time": <EVENT_TIME>,
            "user_data": {
                "em": "<EMAIL>"
            },
            "custom_data": {
                "currency": "<CURRENCY>",
                "value": "<VALUE>"
            },
            "data_processing_options": ["LDU"],
            "data_processing_options_country": 1,
            "data_processing_options_state": 1000
        }
    ]
}

Erfahre mehr über Datenverarbeitungsoptionen.

API-Einschränkungen

Die Marketing API weist eine eigene Logik zur Durchsatzratenbegrenzung auf und ist von allen Graph API-Durchsatzratenbegrenzungen ausgeschlossen. Wenn du also einen Marketing API-Aufruf tätigst, wird dieser nicht in das Graph API-Throttling einbezogen.

Es gibt keine bestimmte Durchsatzratenbegrenzung für die Conversions API. Aufrufe der Conversions API werden als Marketing API-Aufrufe gezählt. Die einzige Beschränkung besteht darin, dass du maximal 1.000 Events auf einmal senden kannst. Weitere Informationen findest du unter Anfragen senden.

Business SDK API – Verwendung im Conversations API Gateway

Dieser Leitfaden unterstützt dich bei der Navigation durch die erweiterten Funktionen des Meta Business SDK, die sich speziell an die Nutzer*innen der Conversions API richten. Informationen zur grundlegenden Verwendung des Conversions API Gateways findest du in der Dokumentation zum Conversions API Gateway.

Events an deine Instanz des Conversions API Gateways senden

Anforderungen

Damit du die unten aufgeführten Funktionen verwenden kannst, musst du das Meta Business SDK installiert haben. Siehe Erste Schritte mit dem Meta Business SDK oder befolge die hier aufgelisteten README-Anweisungen:

• PHP: facebook-php-business-sdk
• Node.js: facebook-nodejs-business-sdk
• Java: facebook-java-business-sdk
• Python: facebook-python-business-sdk
• Ruby: facebook-ruby-business-sdk

Für die Verwendung dieser Funktionen erforderliche Mindestversion der Programmiersprache:

PHP >= 7.2

Java >= 8

Hinweis: Zum Deduplizieren von Events am Conversations API-Endpunkt übergib die eventId in deiner Anfrage. So wird verhindert, dass Events doppelt angezeigt werden, wenn die Veröffentlichung in der Conversations API aktiviert ist.

Die CAPIGatewayIngressRequest-Parameter formatieren

Die CAPIGatewayIngressRequest-Setter

Migrationsbeispiel: PHP

Bei Systemen, die das Business SDK bereits verwenden, musst du lediglich die neue CAPIGatewayIngressRequest referenzieren und sie an das customEndpoint-Objekt der eventRequest anhängen.

// this is the standard event request that we attach events to
$event_request = new EventRequest($this->pixel_id);
$capiIngressRequest = new CAPIGatewayIngressRequest($this->cb_url, $this->access_key);
$event_request->setCustomEndpoint($capiIngressRequest);
// pass the events to this event Request object
$event_request->setEvents($events);
$event_request->execute()

Migrationsbeispiel: Java

Bei Systemen, die das Business SDK bereits verwenden, musst du lediglich die neue CAPIGatewayIngressRequest referenzieren und an das customEndpoint-Objekt der eventRequest anhängen.

// this is the standard event request that we attach events to


EventRequest eventRequest = new EventRequest(PIXEL_ID, context);


CAPIGatewayIngressRequest capiSyncRequest = new CAPIGatewayIngressRequest(CB_URL, CAPIG_ACCESS_KEY);
eventRequest.setCustomEndpoint(capiSyncRequest);
eventRequest.addDataItem(testEvent);
eventRequest.execute();

Synchrone Option

Codebeispiel für PHP

$api = Api::init(null, null, $this->access_token);
$api->setLogger(new CurlLogger());
$event_request = new EventRequest($this->pixel_id);
$capiIngressRequest = new CAPIGatewayIngressRequest($this->cb_url, $this->access_key);
$event_request->setCustomEndpoint($capiIngressRequest);
$user_data = (new UserData())
   ->setEmails(array('joe@eg.com'))
   ->setPhones(array('12345678901', '14251234567'))
   ->setFbc('fb.1.1554763741205.AbCdEfGhIjKlMnOpQrStUvWxYz1234567890')
   ->setFbp('fb.1.1558571054389.1098115397');
$event1 = (new Event())
   ->setEventName('Purchase')
   ->setEventId('125')
   ->setEventTime(time())
   ->setEventSourceUrl('http://jaspers-market.com/product/123')
   ->setUserData($user_data);
$events = array($event1, $event2);
$event_request->setEvents($events);
$response = $event_request->execute();
print($response->__toString());

Codebeispiel für Java

EventRequest eventRequest = new EventRequest(PIXEL_ID, context);
UserData userData = new UserData()
       .email("abc@eg.com");
CAPIGatewayIngressRequest capiSyncRequest = new CAPIGatewayIngressRequest(CB_URL, CAPIG_ACCESS_KEY);
eventRequest.setCustomEndpoint(capiSyncRequest);
Event testEvent = new Event();
testEvent.eventId("125").eventName("Purchase")
       .eventTime(System.currentTimeMillis() / 1000L)
       .userData(userData)
       .dataProcessingOptions(new String[]{}).setEventId("134423232");
eventRequest.namespaceId("11")
       .uploadId("22222")
       .uploadTag("upload-tag-4")
       .uploadSource("upload-source-4")
       .testEventCode("test-event-code-5")
       .partnerAgent("partner-agent-6");
eventRequest.addDataItem(testEvent);
eventRequest.execute();

Asynchrone Option

Codebeispiel für PHP

$api = Api::init(null, null, $this->access_token);
$api->setLogger(new CurlLogger());
$event_request = new EventRequestAsync($this->pixel_id);
$capiIngressRequest = new CAPIGatewayIngressRequest($this->cb_url, $this->access_key);
$capiIngressRequest->setSendToDestinationOnly(true);
$event_request->setCustomEndpoint($capiIngressRequest);
$event1 = (new Event())
   ->setEventName('test Async Event')
   ->setEventId('134423232')
   ->setEventTime(time())
   ->setEventSourceUrl('http://jaspers-market.com/product/123');
$events = array($event1, $event2);
$event_request->setEvents($events);
$response = $event_request->execute()->wait();

Codebeispiel für Java

EventRequest eventRequest = new EventRequest(PIXEL_ID, context);
UserData userData = new UserData()
       .email("abc@eg.com");
CAPIGatewayIngressRequest capiSyncRequest = new CAPIGatewayIngressRequest(CB_URL, CAPIG_ACCESS_KEY);
capiSyncRequest.setSendToDestinationOnly(true);
eventRequest.setCustomEndpoint(capiSyncRequest);
Event testEvent = new Event();
testEvent.eventName("test Async Event")
       .eventTime(System.currentTimeMillis() / 1000L)
       .userData(userData)
       .dataProcessingOptions(new String[]{}).setEventId("134423232");
eventRequest.namespaceId("11222")
       .uploadId("22222")
       .uploadTag("upload-tag-4")
       .uploadSource("upload-source-4")
       .testEventCode("test-event-code-5")
       .partnerAgent("partner-agent-6");
eventRequest.addDataItem(testEvent);
eventRequest.executeAsync();

Filterfunktionalität

Codebeispiel für PHP

lass APIFilter implements Filter {
   public function shouldSendEvent(Event $event): bool
   {
       if ($event->getEventId() === '125') {
           return false;
       }
       return true;
   }
}
$capiIngressRequest = new CAPIGatewayIngressRequest($this->cb_url, $this->access_key);
$event_request->setCustomEndpoint($capiIngressRequest);
$capiIngressRequest->setFilter(new APIFilter());

Codebeispiel für Java

CAPIGatewayIngressRequest capiSyncRequest = new CAPIGatewayIngressRequest(CB_URL, CAPIG_ACCESS_KEY);
eventRequest.setCustomEndpoint(capiSyncRequest);


capiSyncRequest.setFilter(new CustomEndpointRequest.Filter() {
   @Override
   public boolean shouldSendEvent(Event event) {
   if (event.getEventId().equals("125")) {
       return true;
   }
   return false;
}
});

Mehr erfahren

• Conversions API Gateway
• Conversions API Gateway für mehrere Konten
• Parameter der Conversions API
• Best Practices