Públicos dinámicos para productos

Los anuncios del catálogo Advantage+ permiten mostrar anuncios a las personas según su intención de compra en todos los dispositivos. Puedes recopilar señales de intención de los usuarios de apps para celulares y sitios web y, luego, usar esos datos para crear un público y así llegar a clientes potenciales.

En este documento, se explica cómo realizar las siguientes acciones:

Paso 1: Configurar señales de usuarios para eventos

Para recopilar señales de usuarios, usa los eventos de la app en el caso de una app para celulares, o bien el píxel de Meta, si se trata de un sitio web.

Si tienes una app y solo publicas anuncios en computadoras, igualmente deberás instalar el SDK de Facebook. Instalarlo ayuda a capturar las señales y a expandir el público objetivo.

Eventos de la app para celulares

Debes agregar los siguientes eventos a la app 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

Agregar 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 deben incluir un content_id (o una matriz JSON de content_id).

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

Ejemplos

Ejemplo de evento AddToCart en iOS:

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

Evento Purchase en iOS con dos artículos diferentes comprados y su cantidad:

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

Evento Purchase en Android con dos artículos comprados y su 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 Purchase 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 no pueden usarse ni CONTENT_ID ni CONTENT con los anuncios del catálogo Advantage+ para reportar los identificadores del producto. El parámetro CONTENT te permitirá proporcionar información adicional sobre los productos.

Usar un socio de medición de dispositivos móviles

Para usar anuncios del catálogo Advantage+ con un socio de medición de dispositivos móviles (MMP), debes activar los distintos eventos necesarios cuando una persona use tu app. Los puntos de interacción clave que debes registrar son cuando una persona busca productos, ve un producto, agrega algo al carrito y compra artículos. Debes seleccionar los eventos en el MMP que corresponda a los siguientes eventos estándar de anuncios del catálogo Advantage+:

NombreDescripción

fb_mobile_search

Alguien busca productos.

fb_mobile_content_view

Cuando una cuenta del centro de cuentas ve un producto

fb_mobile_add_to_cart

Alguien agrega un artículo al carrito.

fb_mobile_purchase

Una cuenta del centro de cuentas compra uno o más artículos

Además, 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+. Estos dos parámetros representan el identificador del artículo que se vio, se agregó al carrito o se compró, y si corresponde a un producto o a un grupo de productos. Los parámetros adicionales disponibles son los siguientes:

NombreDescripción

fb_content_id

cadena

fb_content_id o fb_content es obligatorio.
Los identificadores de producto o de grupo de productos de la tienda. Debe ser una cadena que contenga una matriz de identificadores con codificación JSON. Si es posible, usa identificadores de productos para obtener una segmentación más precisa.

fb_content

cadena

fb_content_id o fb_content es obligatorio.
Una lista de objetos JSON que contiene el número de artículo internacional (EAN), si corresponde, u otros identificadores de producto o contenido, además de las cantidades y los precios de los productos.


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

fb_content_type

cadena

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


Si no se proporciona ningún fb_content_type, Meta hará que el evento coincida con todos los elementos que tengan el mismo identificador, independientemente del tipo.


Para obtener más información, consulta "Elegir el content_type correcto".

_valueToSum

cadena

Opcional.
El valor total de los productos.

fb_currency

cadena

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

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

Usar el píxel de Meta para los sitios web

Los siguientes eventos deben agregarse a tu sitio web, si corresponde:

  • 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 contents es obligatorio.
Los identificadores de producto o de grupo de productos de la tienda. Si es posible, usa identificadores de productos para una segmentación más precisa.

contents

object[]

content_ids o contents es obligatorio.
Una lista de objetos JSON que contiene los identificadores de producto o de grupo de productos de la tienda e información adicional sobre los productos.


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

content_type

cadena

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


Si no se proporciona ningún content_type, Meta hará que el evento coincida con todos los elementos que tengan el mismo identificador, independientemente del tipo que sean.


Para obtener más información, consulta "Elegir el content_type correcto".

product_catalog_id

cadena

Opcional.
El catálogo de productos que se 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 con el píxel.
Consulta Asociar señales de 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 5 y 10 artículos en content_ids de los resultados de búsqueda principales.

<!-- 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 5 y 10 elementos en content_ids de los resultados principales. Ten en cuenta que ViewCategory no es un evento estándar; por lo tanto, se utiliza 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. Si deseas 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 la plataforma de comercio electrónico gestione la adición de un artículo al carrito. Si se realiza de forma dinámica, debe colocarse en un controlador de eventos onclick para que se active con un clic del botón. Si se carga una página diferente, el evento del píxel puede activarse 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 -->

Si el evento debe activarse con un clic del 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 y su 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 -->

Elegir el content_type correcto

Nota:fb_content_type es el tipo de contenido correspondiente a celulares.

Si la página es sobre un SKU específico (con determinado tamaño, color, etc.), usa product en el caso de content_type y pasa los identificadores de productos (es decir, columna id de la lista de productos) en content_ids. Todos los eventos AddToCart y Purchase deben usar content_type=product porque las personas compran productos específicos. No compran una camisa amorfa de tamaño y color indeterminados, sino que compran una específica con un tamaño y un color concretos.

Si la página es sobre un grupo de productos relacionados de diferente tamaño o color, por ejemplo, usa product_group y pasa los identificadores de grupo de productos (es decir, columna item_group_id de la lista de productos) en content_ids. Un caso típico es el de una página ViewContent, donde el usuario aún no eligió el tamaño. No uses product_group con AddToCart ni con Purchase.

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

Si se pasan identificadores de productos específicos (content_type=product), Meta puede recomendar productos más relevantes porque sabe en qué variante específica (tamaño, color, etc.) expresó interés el usuario. Siempre se mostrarán productos (no grupos de productos), incluso con el valor content_type=product_group.

Si no se proporciona ningún content_type, Meta hará que el evento coincida con todos los elementos que tengan el mismo identificador, independientemente del tipo que sean. 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 usuarios al catálogo de productos

Es necesario que asocies los orígenes de eventos 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 de catálogos del administrador comercial y haz clic en el botón Asociar orígenes de eventos. Asegúrate de seleccionar la app y el píxel que recibirá los eventos de anuncios del catálogo Advantage+.

De manera alternativa, puedes realizar una llamada a la API POST con una lista de orígenes de evento externos como parámetros de cadena de consulta codificados con 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 tener permisos para el catálogo, el píxel, la app y la empresa.

Parámetros

NombreDescripción

external_event_sources

Obligatorio.
Una matriz de los identificadores de la app y del píxel como parámetros de cadena de consulta codificados con UTF-8.

Paso 3: Crear los públicos de productos

El siguiente paso consiste en crear los públicos de productos sobre la base de la actividad en las apps para celulares y el sitio web. Puedes elegir qué eventos usar y segmentar los anuncios usando los públicos de productos.

En relación con los eventos de la app estándar, el público se agregará debajo de los nombres de evento del píxel de anuncios:

  • Search
  • ViewContent
  • AddToCart
  • Purchase

Usa estos nombres de eventos en las reglas del público, incluso si abarcan usuarios de Android y iOS.

Crear un público del producto haciendo una llamada a la API POST al punto de conexión /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.
El nombre del público.

description

cadena

Opcional.
Una descripción del público.

product_set_id

cadena numérica

Obligatorio. Conjunto de productos con el que se segmentará este público.

inclusions

Objeto JSON

Obligatorio.
Un conjunto de eventos para segmentar. Se requiere una inclusión como mínimo. Cada inclusión debe tener exactamente un evento.

inclusions.retention_seconds

entero

Obligatorio.
La cantidad de segundos que la cuenta del centro de cuentas se mantendrá en el público.

inclusions.rule

object[]

Obligatorio.
Regla de público personalizado del sitio web que hace referencia a un event.

exclusions

Objeto JSON

Opcional.
Eventos para los que debe excluirse una cuenta del centro de cuentas de la segmentación.
En el caso de las exclusiones, una cuenta del centro de cuentas con estos eventos se excluirá de la segmentación si el evento ocurrió en algún producto del mismo grupo (es decir, productos con el mismo item_group_id in en la lista de productos).
Por ejemplo, el público del producto incluye ViewContent y excluye los eventos "Purchase". 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, se excluirá a esta cuenta del centro de cuentas del público del producto, ya que A y B son solo variantes. Si los productos A y B no están en el mismo grupo de productos, la cuenta del centro de cuentas permanecerá en el público, porque seguirá teniendo un evento ViewContent para el producto A.

exclusions.retention_seconds

entero

Obligatorio si se especifica la exclusión.
La cantidad de segundos que se mantendrá la exclusión.

exclusions.rule

object[]

Obligatorio si se especifica la exclusión.
Regla de público personalizado del sitio web que hace referencia a un event.

Las reglas deben incluir event con el operador eq, ya sea como 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, todas las comprobaciones de parámetros adicionales deberán ser exactamente iguales.

Ejemplos

Para crear un público dirigido a personas que vieron o agregaron productos a un carrito, pero que no concretaron la compra:

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
'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 vieron un producto en la web con un iPhone, pero no lo compraron en ningún dispositivo, crea el público que se indica a continuación.

Esto supone que incluyes un 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
'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 públicos de productos

Después de crear un público del producto, puedes recuperarlo con la API de públicos personalizados. Puedes obtener los parámetros originales empleados para crear el público con el parámetro data_source.

Un público del producto es un tipo específico de público personalizado que se genera de forma dinámica a partir de eventos de productos. act_{ad-account-id}/product_audiences es un punto de conexión POST especial para construir estos públicos.

Ejemplos

Para recuperar el público personalizado:

curl -X GET \ -d 'fields="data_source,subtype"' \ -d 'access_token=<ACCESS_TOKEN>' \ https://graph.facebook.com/v21.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 un público del 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>