API de Conversões

Como usar a API

Assim que você concluir os pré-requisitos da página Primeiros passos, acesse esta página para aprender a enviar eventos e usar a ferramenta Eventos de Teste. Depois de enviar um evento, verifique a sua configuração.

A API de Conversões tem como base a API de Marketing do Facebook, que foi criada a partir da Graph API. A Graph API e a API de Marketing têm cronogramas diferentes de descontinuação de versões. Nosso ciclo de lançamentos está alinhado com a Graph API para que todas as versões sejam compatíveis por pelo menos dois anos. Essa exceção só é válida para a API de Conversões.

API de Conversões: visão geralParâmetros

Os eventos de loja física, app e web compartilhados usando a API de Conversões exigem parâmetros específicos. Ao usar a API de Conversões, você concorda em garantir a precisão do parâmetro action_source conforme seu conhecimento. A lista de parâmetros obrigatórios está disponível aqui.

Enviar solicitações

Para enviar novos eventos, faça uma solicitação POST para a borda /events dessa API por este caminho: https://graph.facebook.com/{API_VERSION}/{PIXEL_ID}/events?access_token={TOKEN}. Quando você publica nessa borda, o Facebook cria novos eventos de servidor.

curl -X POST \
  -F 'data=[
       {
         "event_name": "Purchase",
         "event_time": 1715940602,
         "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

Anexe o token de acesso seguro gerado usando o parâmetro de consulta access_token para a solicitação. Também é possível usar o Explorador da Graph API para POST no ponto de extremidade /<pixel_id>/events.

Veja um exemplo de corpo de solicitação:

{
   "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
      }
   ]
}

Tempo de carregamento versus tempo de transação do evento

O event_time é o tempo de transação do evento. Ele é enviado como um registro de data e hora do Unix, em segundos, que indica quando o evento ocorreu. O tempo especificado pode estar adiantado em relação ao momento em que você enviou o evento ao Facebook. Isso serve para habilitar o processamento em lote e a otimização de desempenho do servidor.

O event_time pode indicar até 7 dias antes de o evento ser enviado à Meta. Se o event_time de data for maior que 7 dias antes do envio, um erro será retornado para toda a solicitação e nenhum evento será processado. Para eventos de loja física e offline com physical_store definido como action_source, é preciso carregar transações até 62 dias depois da conversão.

Ao usar a API de Conversões, você concorda em garantir a precisão do parâmetro action_source conforme seu conhecimento.

Solicitações em lote

É possível enviar até mil eventos em data. No entanto, para melhor desempenho, recomendamos que você envie os eventos imediatamente após sua ocorrência, preferencialmente até uma hora após a ocorrência. Se houver um evento inválido no lote enviado, todo o lote será rejeitado.

Uso de hash

Verifique a página de parâmetros de informações do cliente para ver quais parâmetros precisam ser convertidos em hashes antes de serem enviados ao Facebook. Se você estiver usando um dos nossos SDKs de Negócios, a conversão em hashes será feita para você pelo SDK.

Recursos de SDK de Negócios para a API de Conversões

Saiba mais sobre três recursos de SDK de Negócios elaborados especialmente para usuários da API de Conversões: Solicitações assíncronas, Criação de lotes concorrentes e Interface de serviço HTTP. Estas são as versões mínimas da linguagem para usar esses recursos:

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

A compatibilidade do SDK de Negócios com o PHP 5 está obsoleta desde janeiro de 2019. Atualize para o PHP 7 para poder usar o SDK de Negócios.

Caso a utilização do PHP 5 seja necessária, considere o uso da implementação do Swagger.

Parâmetros da API de Conversões

Verificação de eventos

Depois de enviar eventos, confirme se eles foram recebidos no Gerenciador de Eventos:

  • Clique em cada evento para obter informações específicas.
  • Depois de enviar eventos, será possível verificá-los em até 20 minutos. Agora, você pode enviar eventos do seu servidor.

Ferramenta Eventos de Teste

É possível usar o recurso Eventos de Teste do Gerenciador de Eventos para verificar se os seus eventos de servidor estão sendo recebidos corretamente pelo Facebook. Para obter a ferramenta, acesse Events Manager > Data Sources > Your Pixel > Test Events.

A ferramenta Eventos de Teste gera um ID de teste. Envie esse ID como um parâmetro test_event_code para ver a atividade do evento na janela dos Eventos de Teste.

Observação: o campo test_event_code deve ser usado apenas para testes. É necessário removê-lo ao enviar sua carga de produção.

Os eventos enviados com test_event_code não são abandonados. Eles vão para o Gerenciador de Eventos e são usados para fazer o direcionamento e a mensuração de anúncios.

Veja aqui um exemplo da estrutura da solicitação:

{
   "data": [
      {
         "event_name": "ViewContent",
         "event_time": 1715940002,
         "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"
}

Veja um exemplo de como a solicitação aparece no Explorador da Graph API:

É possível gerar a carga de teste usando a ferramenta Auxiliar de carga. O código do evento de teste deve ser usado somente para testar a carga.

Quando a solicitação é enviada, os eventos do servidor aparecem na janela dos Eventos de Teste.

Opções de processamento de dados para usuários nos EUA

Para estas duas APIs, implemente opções de processamento de dados adicionando data_processing_options, data_processing_options_country e data_processing_options_state a cada evento no parâmetro de dados dos seus eventos.

Observação: as APIs de Eventos do App e Conversões Offline não são mais recomendadas para novas integrações. Em vez dessas opções, use a API de Conversões, que agora é compatível com eventos da web, de apps e offline. Consulte Conversions API for App Events e Conversions API for Offline Events para saber mais.

Para não habilitar o Uso Limitado de Dados de modo explícito, especifique uma matriz vazia para cada evento ou simplesmente remova o campo na carga:

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

Para habilitar o Uso Limitado de Dados e fazer com que a Meta realize a geolocalização:

{
    "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
        }
    ]
}

Para habilitar o Uso Limitado de Dados e especificar manualmente a localização (por exemplo, para a Califórnia):

{
    "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
        }
    ]
}

Interface do usuário para carregamento manual

A API de Conversões Offline oferece a opção de carregar manualmente seus eventos a partir de um arquivo .csv. Nesse caso, adicione "Opções de processamento de dados", "País para processamento de dados" e "Estado para processamento de dados" como colunas dentro do seu arquivo. Para saber mais, consulte a interface do usuário para carregamento.


Saiba mais sobre as opções de processamento de dados.

Limites da API

A API de Marketing tem a própria lógica de limitação de volume e está excluída de todos os limites de volume da Graph API. Assim, se você fizer uma chamada da API de Marketing, ela não será considerada na limitação da Graph API.

Não há um limite de volume específico para a API de Conversões. As chamadas da API de Conversões são contadas como chamadas da API de Marketing. A única limitação é o máximo de mil eventos que podem ser enviados por vez. Consulte Enviar solicitações para mais informações.

Limitação de volume da API de Marketing

Uso da API do SDK de Negócios no Conversions API Gateway

Este guia ajuda você a navegar pelos recursos avançados do SDK de Negócios da Meta que foram criados especialmente para usuários do Conversions API Gateway. Para um uso básico, consulte a documentação sobre o Conversions API Gateway.

Enviar eventos à instância do Conversions API Gateway

Requisitos

Antes de usar os recursos listados abaixo, é preciso instalar o SDK de Negócios da Meta. Consulte Introdução ao SDK de Negócios da Meta ou siga as instruções README exibidas aqui:

No momento, esses recursos estão disponíveis apenas no SDK de Negócios em PHP e Java. As outras linguagens serão implementadas até o final de 2023.

Estas são as versões mínimas para usar os recursos:

PHP >= 7.2

Java >= 8

Observação: para desduplicar eventos no ponto de extremidade da API de Conversões, transmita o eventId na sua solicitação. Isso ajuda a evitar a exibição de eventos duplicados quando a publicação da API de Conversões está habilitada.

Formatar os parâmetros CAPIGatewayIngressRequest

ParâmetroDescrição
endpointUrl
string

O ponto de extremidade do Conversions API Gateway para o qual os eventos são enviados. Não será realizada nenhuma validação prévia no parâmetro, apenas a verificação de que se trata de uma URL válida.


Exemplo: https://test.example.com


accessKey
string

Chave de acesso necessária para enviar eventos ao ponto de extremidade de eventos do Conversions API Gateway. Veja as instruções para gerá-la.

Os setters CAPIGatewayIngressRequest

ParâmetroDescrição
setSendToDestinationOnly
Booleano

Sinalizador booliano que informa se os eventos foram enviados somente para o ponto de extremidade selecionado.


Padrão: False


setFilter
Função CustomEndpointRequest.Filter()

Função de filtro que processa cada evento. Se a lógica de filtragem retornar "true", o evento será transmitido. Caso contrário, os eventos serão descartados. É preciso implementar a função shouldSendEvent na interface que possui o parâmetro Event.


Padrão: Null



Exemplo de migração: PHP

Para sistemas que já utilizam o SDK de Negócios, basta referenciar o novo CAPIGatewayIngressRequest e anexá-lo ao objeto customEndpoint de eventRequest.

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

Exemplo de migração: Java

Para sistemas que já utilizam o SDK de Negócios, basta referenciar o novo CAPIGatewayIngressRequest e anexá-lo ao objeto customEndpoint de eventRequest.

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

Opção síncrona

Exemplo de código 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());

Exemplo de código 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();

Opção assíncrona

Exemplo de código 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();

Exemplo de código 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();

Funcionalidade de filtro

Exemplo de código 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());

Exemplo de código 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;
}
});

Saiba mais