API de marketing

Audiencias de productos dinámicos

Los anuncios de catálogo de Advantage+ permiten mostrar a los usuarios anuncios según su intención de compra en todos los dispositivos. Puedes obtener señales de intención de los usuarios de aplicaciones para móviles y sitios web y, a continuación, usar los datos para crear una audiencia con el fin de segmentar clientes potenciales.

En este documento se explican los pasos siguientes:

Paso 1: Configurar señales de usuario para eventos

Para obtener señales del usuario, usa los eventos de la aplicación para la aplicación para móviles o el píxel de Meta para el sitio web.

Si tienes una aplicación y solo publicas anuncios para ordenadores, debes instalar el SDK de Facebook igualmente. De esta forma, es más fácil recoger señales y ampliar la audiencia objetivo.

Eventos de la aplicación para móviles

Debes añadir los eventos siguientes a la aplicación mediante el SDK de Facebook para iOS y Android:

EventoEvento de iOSEvento de Android

Búsqueda

FBSDKAppEventNameSearched

EVENT_NAME_SEARCHED

Ver contenido

FBSDKAppEventNameViewedContent

EVENT_NAME_VIEWED_CONTENT

Añadir al carrito

FBSDKAppEventNameAddedToCart

EVENT_NAME_ADDED_TO_CART

Compra

// Se envía mediante logPurchase
[[FBSDKAppEvents shared] logPurchase:(double) currency:(NSString *) parameters:(NSDictionary *)];

EVENT_NAME_PURCHASED

Todos estos eventos deberían incluir un content_id (o una matriz JSON de content_id).

A diferencia del píxel de Meta, los eventos de la aplicación no tienen ningún parámetro product_catalog_id. Por este motivo, debes realizar una asociación entre el catálogo y la aplicación con el extremo external_event_sources que se describe a continuación.

Ejemplos

Evento de artículo añadido al carrito en iOS:

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

Evento de compra en iOS con dos artículos diferentes comprados con la cantidad:

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

Evento de compra en Android con dos artículos comprados con la cantidad:

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 de compra en Android con dos artículos comprados:

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

Ten en cuenta que se puede usar CONTENT_ID o CONTENT con los anuncios de catálogo de Advantage+ para informar sobre identificadores de producto. Con el parámetro CONTENT podrás proporcionar más información acerca de los productos.

Uso de un socio de evaluación de la actividad en móviles

Para usar anuncios de catálogo de Advantage+ con un socio de evaluación de la actividad en móviles (MMP), debes activar los distintos eventos obligatorios cuando alguien use la aplicación. Los puntos de interacción clave de los que debes hacer un seguimiento son el momento en que alguien busca productos, visualiza un producto, añade algo al carrito y compra artículos. Debes seleccionar los eventos en el MMP correspondiente a los siguientes eventos de anuncios de catálogo de Advantage+ estándar:

NombreDescripción

fb_mobile_search

Alguien busca productos.

fb_mobile_content_view

Una cuenta del Centro de cuentas ve un producto.

fb_mobile_add_to_cart

Alguien añade un artículo al carrito.

fb_mobile_purchase

Una cuenta del Centro de cuentas compra uno o varios artículos.

También necesitas dos parámetros adicionales para que cada uno de los eventos se registre correctamente como un evento de anuncios de catálogo de Advantage+ válido. Estos dos parámetros representan el identificador del artículo que se ha visualizado, añadido al carrito o comprado, y si el identificador corresponde a un producto o a un grupo de productos. Los parámetros adicionales disponibles son:

NombreDescripción

fb_content_id

Cadena

fb_content_id o bien fb_content es obligatorio.
Identificadores de productos o de grupos de productos del minorista. Debe ser una cadena que contenga una matriz de identificadores con codificación JSON. Usa identificadores de productos si es posible para mejorar la precisión de la segmentación.

fb_content

Cadena

fb_content_id o bien fb_content es obligatorio.
Lista de objetos JSON que contiene el número internacional de artículo (EAN), cuando corresponde, u otros identificadores de producto o contenido, así como las cantidades y los precios de los productos.


id y quantity son los campos obligatorios.
Ejemplo:
"[{\"id\": \"1234\", \"quantity\": 2}, {\"id\": \"5678\", \"quantity\": 1}]"

fb_content_type

Cadena

Opcional.
O bien product, o bien product_group, que debe sincronizarse con el tipo de identificadores utilizados como fb_content_id.


Si no se proporciona ningún valor para fb_content_type, Meta hará coincidir el evento con todos los artículos que tengan el mismo identificador, independientemente del tipo.


Consulta “Elección del content_type correcto” para obtener más información.

_valueToSum

Cadena

Opcional.
Valor total de los productos.

fb_currency

Cadena

Opcional.
Divisa del producto o el importe de la compra.

Nota: Se recomienda enviar los parámetros _valueToSum y fb_currency cuando se realice una compra.

Usar el píxel de Meta para sitios web

En caso de que sea posible, debes añadir los eventos siguientes al sitio web:

  • Search
  • ViewCategory
  • ViewContent
  • AddToCart
  • Purchase

Estos eventos deben enviarse con los siguientes parámetros de datos:

NombreDescripción

content_ids

cadena o cadena[]

content_ids o bien contents es obligatorio.
Los identificadores de productos o de grupos de productos del minorista. Usa identificadores de productos si es posible para mejorar la precisión de la segmentación.

contents

Objeto[]

content_ids o bien contents es obligatorio.
Lista de objetos JSON que contiene los identificadores de productos o de grupos de productos del minorista.


Los campos id y quantity son obligatorios.
Ejemplo:. [{"id": "1234", "quantity": 2}, {"id": "5678", "quantity": 1}]

content_type

Cadena

Opcional.
O bien product, o bien product_group, que debe sincronizarse con el tipo de identificadores utilizados como content_ids.


Si no se proporciona ningún valor para content_type, Meta hará coincidir el evento con todos los artículos que tengan el mismo identificador, independientemente del tipo.


Consulta “Elección del content_type correcto” para obtener más información.

product_catalog_id

Cadena

Opcional.
El catálogo de productos que se va a usar. Si se proporciona, será el único catálogo con el que estarán asociadas las activaciones del píxel. Si no se proporciona, se usarán los catálogos asociados al píxel.
Consulta Asociar señales de los usuarios al catálogo de productos para obtener más información.

Ejemplos

A continuación, se muestra un evento Search estándar. Se recomienda proporcionar entre cinco y diez artículos en content_ids de los resultados principales de la búsqueda.

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

A continuación, se muestra un evento ViewCategory. Se recomienda proporcionar entre cinco y diez artículos en content_ids de los resultados principales. Ten en cuenta que ViewCategory no es un evento estándar y que, por este motivo, se usa la función 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 -->

A continuación, se muestra un evento ViewContent estándar. Para obtener más información sobre la configuración del píxel, consulta Píxel de 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 AddToCart estándar depende de cómo gestione tu plataforma de comercio electrónico la adición de un artículo al carrito. Si se lleva a cabo de forma dinámica, debería colocarse en un controlador de evento onclick para que se active cuando se haga clic en el botón. Si se carga una página diferente, el evento del píxel se puede activar de manera normal.

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

Si el evento debe activarse con el clic de un botón y no se carga ninguna página diferente:

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

Un evento Purchase estándar con dos artículos con la cantidad:

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

Un evento Purchase estándar con dos artículos:

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

Elección del parámetro content_type correcto

Nota:fb_content_type es el tipo de contenido para móviles.

Si la página trata sobre un SKU específico (talla específica, color específico, etc.), usa product para content_type y pasa los identificadores de productos (es decir, la columna id de la lista de productos) en content_ids. Todos los eventos AddToCart y Purchase deben usar content_type=product porque los usuarios compran productos específicos. Los usuarios no compran una camisa amorfa en una talla y un color indeterminados, sino que adquieren una camisa específica en una talla y un color concretos.

Si la página trata sobre un grupo de productos relacionados que varían según la talla, el color, etc., pero pertenecen al mismo grupo de productos, usa product_group y pasa los identificadores del grupo de productos (es decir, la columna item_group_id de la lista de productos) en content_ids. Un caso de uso habitual es una página ViewContent en la que el usuario todavía no ha elegido la talla. No usesproduct_group con AddToCart ni Purchase.

Es importante que content_type coincida con el tipo de identificadores incluidos en el parámetro content_ids o contents.

Si pasas los identificadores de productos específicos (content_type=product), Meta podrá recomendar más productos relevantes, porque sabrá en qué variante concreta (talla, color, etc.) mostró interés el usuario. Siempre mostraremos productos (no grupos de productos), incluso aunque sea content_type=product_group.

Si no se proporciona ningún valor para content_type, Meta hará coincidir el evento con todos los artículos que tengan el mismo identificador, independientemente del tipo. Se recomienda enviar content_type, ya que te dará más control sobre qué identificador específico quieres que coincida con el evento.

Paso 2: Asociar señales de usuario al catálogo de productos

Debes asociar los orígenes del evento a cada uno de tus catálogos de productos para que Facebook pueda obtener estos datos y mostrar el producto correcto en un anuncio. Para ello, visita la página del catálogo de Business Manager y haz clic en el botón Asociar origen del evento. Asegúrate de seleccionar la aplicación y el píxel que recibirán los eventos de anuncios de catálogo de Advantage+.

Otra opción es realizar una llamada POST a la API con una lista de los orígenes de evento externos como parámetros de una cadena de consulta codificada en 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: Debes contar con permisos para el catálogo, el píxel y la aplicación, así como para la empresa.

Parámetros

NombreDescripción

external_event_sources

Obligatorio.
Matriz de identificadores de la aplicación y del píxel que se van a asociar como parámetros de una cadena de consulta codificada en UTF-8.

Paso 3: Crear audiencias de productos

El siguiente paso es crear audiencias de productos en función de la actividad de las aplicaciones para móviles y el sitio web. Puedes seleccionar los eventos que quieres usar y segmentar los anuncios mediante las audiencias de productos.

Para los eventos de la aplicación estándar, la audiencia se agregará bajo los nombres de evento del píxel de anuncios:

  • Search
  • ViewContent
  • AddToCart
  • Purchase

Usa estos nombres de evento en las reglas de la audiencia, aunque incluya usuarios de Android e iOS.

Para crear una audiencia de productos, realiza una llamada POST a la API al extremo /act_{ad-account-id}/product_audiences.

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

Parámetros

NombreDescripción

name

Cadena

Obligatorio.
Nombre de la audiencia.

description

Cadena

Opcional.
Descripción de la audiencia.

product_set_id

cadena numérica

Obligatorio. Conjunto de productos al que se va a dirigir esta audiencia.

inclusions

Objeto JSON

Obligatorio.
Conjunto de eventos para la segmentación. Se requiere una inclusión como mínimo. Cada inclusión debe tener exactamente un evento.

inclusions.retention_seconds

Entero

Obligatorio.
Número de segundos que la cuenta del Centro de cuentas se va a mantener en la audiencia.

inclusions.rule

Objeto[]

Obligatorio.
Regla de audiencia personalizada del sitio web que hace referencia a un elemento event.

exclusions

objeto JSON

Opcional.
Eventos para los que una cuenta del Centro de cuentas debe excluirse de la segmentación.
Para las exclusiones, una cuenta del Centro de cuentas con estos eventos se excluirá de la segmentación si el evento ha tenido lugar en algún producto del mismo grupo (es decir, productos con el mismo item_group_id in en la lista de productos).
Por ejemplo, una audiencia del producto está configurada para incluir ViewContent y excluir eventos de compra. Una cuenta del Centro de cuentas ve los productos A y B, y compra el producto B. Si el producto A y el producto B pertenecen al mismo grupo de productos, esta cuenta del Centro de cuentas se excluirá de la audiencia de productos, ya que A y B son solo variantes. Si los productos A y B no pertenecen al mismo grupo de productos, la cuenta del Centro de cuentas permanecerá en la audiencia, porque todavía tendrá un evento ViewContent para el producto A.

exclusions.retention_seconds

Entero

Obligatorio si se especifica la exclusión.
Número de segundos que se retendrá la exclusión.

exclusions.rule

Objeto[]

Obligatorio si se especifica la exclusión.
Regla de audiencia personalizada del sitio web que hace referencia a un event.

Cada regla debe incluir event con el operador eq, ya sea como una regla de nivel superior o como parte de una regla and de nivel superior.

Si se usa el mismo event en las inclusiones y las exclusiones, cualquier comprobación adicional de parámetros deberá ser exactamente la misma.

Ejemplos

Para crear una audiencia dirigida a personas que han visualizado o añadido productos a un carrito, pero que no los han comprado:

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

Si quieres dirigirte a personas que han visualizado un producto en la web con un iPhone, pero no lo han comprado en ningún dispositivo, crea la audiencia que se indica a continuación.

Esto supone que incluyes el parámetro userAgent en el píxel de 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

Recuperar audiencias de productos

Cuando crees una audiencia de un producto, puedes recuperarla con la API de audiencias personalizadas. Puedes obtener los parámetros originales utilizados para la creación de la audiencia con el parámetro data_source.

Una audiencia de un producto es un tipo específico de audiencia personalizada que se genera de forma dinámica a partir de los eventos de productos. El extremo act_{ad-account-id}/product_audiences es un extremo POST especial para crear estas audiencias.

Ejemplos

Para recuperar una audiencia personalizada:

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

Para recuperar una audiencia de un producto específico:

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>

Más información