API Marketing

Gruppi di pubblico del prodotto dinamico

Le inserzioni del catalogo Advantage+ ti permettono di mostrare alle persone inserzioni in base alla loro intenzione di acquisto cross-device. Puoi raccogliere i segnali delle intenzioni degli utenti dalle app mobili e dai siti web e usare questi dati per creare un pubblico in modo da targetizzare i potenziali clienti.

Questo documento illustra come:

Passaggio 1: configurare i segnali dell'utente per gli eventi

Per raccogliere i segnali dell'utente, usa App Events per l'app mobile o il pixel di Meta per il sito web.

Se disponi di un'app e pubblichi le inserzioni solo per computer, devi comunque installare l'SDK di Facebook. Questo aiuta a catturare segnali ed espandere il pubblico di destinazione.

App Events per mobile

Devi aggiungere i seguenti eventi alla tua app attraverso SDK di Facebook per iOS e Android:

EventoEvento iOSEvento Android

Ricerca

FBSDKAppEventNameSearched

EVENT_NAME_SEARCHED

Visualizzazione di contenuti

FBSDKAppEventNameViewedContent

EVENT_NAME_VIEWED_CONTENT

Aggiunta al carrello

FBSDKAppEventNameAddedToCart

EVENT_NAME_ADDED_TO_CART

Acquisto

// Send through logPurchase
[[FBSDKAppEvents shared] logPurchase:(double) currency:(NSString *) parameters:(NSDictionary *)];

EVENT_NAME_PURCHASED

Tutti questi eventi devono includere un content_id (oppure un array JSON di content_id).

A differenza del pixel di Meta, App Events non ha il parametro product_catalog_id. Di conseguenza devi associare il catalogo e l'app all'endpoint external_event_sources descritto sotto.

Esempi

Evento di aggiunta al carrello su iOS:

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

Evento di acquisto su iOS con due articoli diversi acquistati con quantità:

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

Evento di acquisto su Android con due articoli acquistati con quantità:

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

Evento di acquisto su Android con due articoli acquistati:

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

Considera che con le inserzioni del catalogo Advantage+ è possibile usare CONTENT_ID o CONTENT per indicare gli ID dei prodotti. Il parametro CONTENT ti consente di fornire informazioni aggiuntive sui prodotti.

Utilizzo di un Mobile Measurement Partner

Per usare le inserzioni del catalogo Advantage+ con un Mobile Measurement Partner (MMP), devi avviare separatamente gli eventi richiesti mentre una persona utilizza la tua app. I punti di interazione chiave che devi monitorare sono quando qualcuno cerca dei prodotti, visualizza un prodotto, aggiunge qualcosa a un carrello e acquista gli articoli. Devi selezionare gli eventi nel tuo MMP che corrispondono ai seguenti eventi delle inserzioni del catalogo Advantage+ standard:

NomeDescrizione

fb_mobile_search

Una persona cerca dei prodotti.

fb_mobile_content_view

Un account del Centro gestione account visualizza un prodotto.

fb_mobile_add_to_cart

Una persona aggiunge un articolo al carrello.

fb_mobile_purchase

Un account del Centro gestione account acquista uno o più articoli.

Inoltre, ti occorrono altri due parametri per registrare correttamente ciascun evento come un evento di inserzioni del catalogo Advantage+. Questi due parametri rappresentano l'ID dell'articolo che viene visualizzato, aggiunto al carrello o acquistato e indicano se l'ID è un prodotto o un gruppo di prodotti. I parametri aggiuntivi disponibili sono:

NomeDescrizione

fb_content_id

stringa

Uno tra fb_content_id e fb_content è obbligatorio.
Uno o più ID di prodotti o gruppi di prodotti del rivenditore. Deve essere una stringa che contiene un array codificato JSON di ID. Se possibile, usa gli ID dei prodotti per una targetizzazione più precisa.

fb_content

stringa

Uno tra fb_content_id e fb_content è obbligatorio.
Una lista di oggetti JSON che contiene il numero EAN (codice identificativo articolo internazionale), se applicabile, o altri identificativi di prodotto o contenuto, nonché quantità e prezzi dei prodotti.


I campi id e quantity sono obbligatori.
Esempio:
"[{\"id\": \"1234\", \"quantity\": 2}, {\"id\": \"5678\", \"quantity\": 1}]"

fb_content_type

stringa

Facoltativo.
Uno tra product e product_group, che deve essere sincronizzato con il tipo di ID utilizzati come fb_content_id.


Se non viene fornito alcun content_type, Meta assocerà l'evento a ogni elemento con lo stesso ID, indipendentemente dal tipo.


Consulta "Scegliere il giusto content_type" per saperne di più.

_valueToSum

stringa

Facoltativo.
Il valore totale dei prodotti.

fb_currency

stringa

Facoltativo.
La valuta del prodotto o l'importo dell'acquisto.

Nota: è consigliabile inviare i parametri _valueToSum e fb_currency quando viene effettuato un acquisto.

Utilizzo del pixel di Meta per i siti web

I seguenti eventi devono essere aggiunti al tuo sito web, se applicabile:

  • Search
  • ViewCategory
  • ViewContent
  • AddToCart
  • Purchase

Questi eventi devono essere inviati con i seguenti parametri di dati:

NomeDescrizione

content_ids

stringa o stringa[]

Uno tra content_ids e contents è obbligatorio.
Uno o più ID di prodotti o gruppi di prodotti del rivenditore. Se possibile, usa gli ID dei prodotti per una targetizzazione più precisa.

contents

oggetto[]

Uno tra content_ids e contents è obbligatorio.
Una lista di oggetti JSON contenente uno o più ID di prodotti o gruppi di prodotti del rivenditore insieme a ulteriori informazioni sui prodotti.


I campi id e quantity sono obbligatori
Esempio:. [{"id": "1234", "quantity": 2}, {"id": "5678", "quantity": 1}]

content_type

stringa

Facoltativo.
Uno tra product e product_group, che deve essere sincronizzato con il tipo di ID utilizzati come content_ids.


Se non viene fornito alcun content_type, Meta assocerà l'evento a ogni elemento con lo stesso ID, indipendentemente dal tipo.


Consulta "Scegliere il giusto content_type" per saperne di più.

product_catalog_id

stringa

Facoltativo.
Il catalogo prodotti da utilizzare. Se viene fornito, questo sarà l'unico catalogo associato al pixel. Se non viene fornito, verranno utilizzati i cataloghi associati al tuo pixel.
Vedi la sezione Associare i segnali utente al catalogo prodotti per ulteriori informazioni.

Esempi

Di seguito è mostrato un esempio di evento standard Search. Consigliamo di fornire da 5 a 10 articoli per content_ids dai principali risultati della tua ricerca.

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

Di seguito è mostrato un esempio di evento ViewCategory. Consigliamo di fornire da 5 a 10 articoli per content_ids dai principali risultati della tua ricerca. Tieni presente che ViewCategory non è un evento standard, quindi viene usata la funzione trackCustom.

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

Di seguito è mostrato un esempio di evento standard ViewContent. Per maggiori dettagli sulla configurazione del pixel, consulta Pixel di Meta.

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

Un evento standard AddToCart dipende da come la piattaforma di e-commerce gestisce l'aggiunta di un articolo al carrello. Se viene fatto in modo dinamico, viene collocato in un gestore di eventi onclick in modo da venire attivato al clic sul pulsante. Se viene caricata una pagina a parte, l'evento del pixel può essere attivato normalmente.

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

Se l'evento deve essere attivato al clic sul pulsante e non viene caricata alcuna pagina a parte:

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

Evento standard Purchase con due articoli con quantità:

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

Evento standard Purchase con due articoli:

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

Scegliere il giusto content_type

Nota:fb_content_type è il tipo di contenuto per dispositivi mobili.

Se la pagina riguarda una SKU specifica (dimensioni, colore e così via), utilizza product per content_type e passa gli ID prodotto (colonna id nell'elenco prodotti) in content_ids. Tutti gli eventi AddToCart e Purchase devono utilizzare content_type=product perché le persone acquistano prodotti specifici. Le persone non acquistano una camicia senza forma di taglia e colore indefiniti, ma una camicia specifica di taglia e colore determinati.

Se la pagina riguarda un gruppo di prodotti correlati con dimensioni, colore ecc. variabili ma appartenenti allo stesso gruppo di prodotti, usa product_group e passa gli ID gruppo prodotti (colonna item_group_id nell'elenco prodotti) in content_ids. Un caso d'uso comune è quello di una pagina ViewContent in cui l'utente non ha ancora scelto la taglia. Non usareproduct_group con AddToCart o Purchase.

È importante che il content_type corrisponda al tipo di ID incluso nel parametro content_ids o contents.

Passando ID prodotti specifici (content_type=product) Meta è in grado di consigliare un maggior numero di prodotti rilevanti poiché ha le informazioni necessarie relative alla variante specifica (taglia, colore e così via) per la quale l'utente ha manifestato interesse. Verranno visualizzati sempre prodotti (non gruppi di prodotti), anche se content_type=product_group.

Se non viene fornito alcun content_type, Meta assocerà l'evento a ogni elemento con lo stesso ID, indipendentemente dal tipo. Si consiglia di inviare content_type, poiché ti darà maggiore controllo sull'ID specifico da associare all'evento.

Passaggio 2: associare i segnali utente al catalogo prodotti

Devi associare le origini degli eventi a ciascuno dei tuoi cataloghi prodotti in modo che Facebook possa ottenere questi dati e mostrare il prodotto corretto in un'inserzione. Puoi eseguire questa operazione accedendo alla pagina del catalogo del Business Manager e cliccando sul pulsante Associa origine evento. Assicurati di selezionare l'app e il pixel che riceveranno gli eventi delle inserzioni del catalogo Advantage+.

In alternativa, puoi effettuare una chiamata API POST con una lista di origini di eventi esterne come i parametri di una stringa di query con codifica UTF-8:

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

Nota: devi avere le autorizzazioni per catalogo, pixel e app così come per l'azienda.

Parametri

NomeDescrizione

external_event_sources

Obbligatorio.
Un array di ID app e pixel da associare come parametri della stringa della query con codifica UTF-8

Passaggio 3: creare gruppi di pubblico del prodotto

Il passo successivo è la creazione dei gruppi di pubblico del prodotto sulla base dell'attività su app mobili e sito web. Puoi scegliere quali eventi usare e targetizzare le inserzioni usando i gruppi di pubblico del prodotto.

Per gli eventi delle app standard, il pubblico sarà aggregato sotto i nomi delle azioni del pixel delle inserzioni:

  • Search
  • ViewContent
  • AddToCart
  • Purchase

Usa questi nomi di eventi nelle tue regole per il pubblico, anche se sono inclusi utenti su Android e iOS.

Crea il pubblico del prodotto effettuando una chiamata API POST all'endpoint /act_{ad-account-id}/product_audiences.

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

Parametri

NomeDescrizione

name

stringa

Obbligatorio.
Il nome del pubblico.

description

stringa

Facoltativo.
Una descrizione del pubblico.

product_set_id

stringa numerica

Obbligatorio. L'insieme di prodotti di destinazione per questo pubblico

inclusions

Oggetto JSON

Obbligatorio.
Un insieme di eventi da targetizzare. Occorre almeno un'inclusione. Ciascuna inclusione deve avere esattamente un evento.

inclusions.retention_seconds

int

Obbligatorio.
Il numero di secondi per i quali mantenere l'account del Centro gestione account nel pubblico.

inclusions.rule

oggetto[]

Obbligatorio.
Regola del pubblico personalizzato dal sito web che fa riferimento a un event.

exclusions

Oggetto JSON

Facoltativo.
Gli eventi per cui un account del Centro gestione account deve essere escluso dalla targetizzazione.
Per le esclusioni, un account del Centro gestione account con questi eventi sarà escluso dalla targetizzazione se l'evento si è svolto su un qualsiasi prodotto dello stesso gruppo di prodotti (in altre parole, i prodotti che hanno lo stesso item_group_id in nell'elenco di prodotti).
Ad esempio, poniamo che il pubblico del prodotto sia impostato per includere ViewContent ed escludere gli eventi di acquisto. Un account del Centro gestione account vede i prodotti A e B e acquista il prodotto B. Se questi due prodotti appartengono allo stesso gruppo di prodotti, quell'account sarà escluso dal pubblico del prodotto perché A e B sono solo varianti. Se i prodotti A e B non appartengono allo stesso gruppo di prodotti, quell'account continuerà a rimanere nel pubblico perché ha ancora un evento ViewContent per il prodotto A.

exclusions.retention_seconds

int

Obbligatorio, se è specificata l'esclusione.
Il numero di secondi per i quali mantenere l'esclusione.

exclusions.rule

oggetto[]

Obbligatorio, se è specificata l'esclusione.
Regola del pubblico personalizzato dal sito web che fa riferimento a un event.

Ogni regola deve includere event con l'operatore eq come regola di livello superiore o come parte di una regola and di livello superiore.

Se viene usato lo stesso event sia nelle inclusioni che nelle esclusioni, tutti gli ulteriori parametri devono essere esattamente gli stessi.

Esempi

Creare un pubblico che includa persone che hanno visualizzato o aggiunto prodotti al carrello senza aver completato l'acquisto:

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

Se vuoi definire come destinatarie le persone che hanno visualizzato un prodotto sul web con iPhone, ma che non hanno acquistato alcun dispositivo, crea il pubblico riportato di seguito.

Questa operazione prevede che tu includa un parametro userAgent nel tuo pixel di Meta.

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

Recuperare i gruppi di pubblico del prodotto

Una volta creato il pubblico del prodotto, puoi recuperarlo con l'API Custom Audiences. Puoi ottenere i parametri originali usati per la creazione del pubblico con il parametro data_source.

Il pubblico del prodotto è un tipo specifico di pubblico personalizzato generato in modo dinamico dagli eventi relativi al prodotto. L'endpoint act_{ad-account-id}/product_audiences è un endpoint POST specifico per creare questi gruppi di pubblico.

Esempi

Recupero del pubblico personalizzato:

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

Recupero di uno specifico gruppo di pubblico del prodotto:

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>

Scopri di più