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:

Configurar señales de usuario para eventos
Asociar señales de usuario al catálogo
Crear audiencias de productos
Recuperar audiencias de productos

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:

Evento	Evento de iOS	Evento de Android
Buscar	`FBSDKAppEventNameSearched`	`EVENT_NAME_SEARCHED`
Ver contenido	`FBSDKAppEventNameViewedContent`	`EVENT_NAME_VIEWED_CONTENT`
Añadir al carrito	`FBSDKAppEventNameAddedToCart`	`EVENT_NAME_ADDED_TO_CART`
Comprar	// Enviar mediante logPurchase `[FBSDKAppEvents 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 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 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:

Nombre	Descripció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:

Nombre	Descripció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:

Nombre	Descripció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

Nombre	Descripció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/v19.0/act_AD_ACCOUNT_ID/product_audiences

Parámetros

Nombre	Descripció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/v19.0/act_<AD_ACCOUNT_ID>/product_audiences


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


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


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


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

  }
}


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'}}}],
})

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/v19.0/act_<AD_ACCOUNT_ID>/product_audiences


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


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


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


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

  }
}


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'}}}],
})

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/v19.0/act_<AD_ACCOUNT_ID>/customaudiences


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


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


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


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

  }
}


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' },
})

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

Consulta la referencia del catálogo de productos.
Consulta la referencia de las audiencias personalizadas.

Audiencias de productos dinámicos

Paso 1: Configurar señales de usuario para eventos

Eventos de la aplicación para móviles

Ejemplos

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

Usar el píxel de Meta para sitios web

Ejemplos

Elección del parámetro content_type correcto

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

Parámetros

Paso 3: Crear audiencias de productos

Parámetros

Ejemplos

Recuperar audiencias de productos

Ejemplos

Más información

Elección del parámetro `content_type` correcto