Públicos personalizados de apps para celulares

Crea públicos según las acciones de las personas en la aplicación que cumplan tus criterios. Esta función te permite crear un público que, por ejemplo:

• "Superó el nivel 8 en los últimos 10 días".
• "Usó la app en los últimos 8 días, pero no hizo compras".
• "Agregó artículos al carrito, pero no compró".

Esta solución utiliza eventos registrados a través de nuestros SDK de Facebook, la API de eventos de la app o socios de medición de dispositivos móviles. Los ejemplos de eventos por registrar incluyen "Instalado", "Agregado al carrito", "Comprado" o "Alcanzó un nivel".

Limitaciones

• subtype para públicos personalizados de interacción solo se admite en el caso de videos.
• Los públicos personalizados de apps para celulares para segmentación de inclusión ya no son compatibles con el punto de conexión POST /{ad-account-id}/adsets para campañas de SKAdNetwork de iOS 14.5 en adelante.
• Las nuevas campañas de instalación de apps de iOS 14.5 ya no podrán usar segmentación por conexiones de apps.

Crear un público

Para crear públicos personalizados desde la aplicación para celulares, la cuenta publicitaria debe aceptar las Condiciones de servicio para públicos personalizados, en el administrador de anuncios. Para aceptar las condiciones:

• Debes ser administrador, desarrollador o usuario de estadísticas de la cuenta publicitaria.
• Tu cuenta publicitaria debe figurar como cuenta publicitaria en la configuración de tu app.

Para crear un público:

curl -X POST \
  -F 'name="My Test Website Custom Audience"' \
  -F 'rule={
       "inclusions": {
         "operator": "or",
         "rules": [
           {
             "event_sources": [
               {
                 "id": "<APP_ID>",
                 "type": "app"
               }
             ],
             "retention_seconds": 8400,
             "filter": {
               "operator": "and",
               "filters": [
                 {
                   "field": "event",
                   "operator": "eq",
                   "value": "fb_mobile_purchase"
                 }
               ]
             }
           }
         ]
       }
     }' \
  -F 'prefill=1' \
  -F '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 = [
];
params = {
  'name' : 'My Test Website Custom Audience',
  'rule' : {'inclusions':{'operator':'or','rules':[{'event_sources':[{'id':'<appID>','type':'app'}],'retention_seconds':8400,'filter':{'operator':'and','filters':[{'field':'event','operator':'eq','value':'fb_mobile_purchase'}]}}]}},
  'prefill' : '1',
};
const customaudiences = (new AdAccount(id)).createCustomAudience(
  fields,
  params
);
logApiCallResult('customaudiences api call complete.', customaudiences);

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' => 'My Test Website Custom Audience',
  'rule' => array('inclusions' => array('operator' => 'or','rules' => array(array('event_sources' => array(array('id' => '<appID>','type' => 'app')),'retention_seconds' => 8400,'filter' => array('operator' => 'and','filters' => array(array('field' => 'event','operator' => 'eq','value' => 'fb_mobile_purchase'))))))),
  'prefill' => '1',
);
echo json_encode((new AdAccount($id))->createCustomAudience(
  $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': 'My Test Website Custom Audience',
  'rule': {'inclusions':{'operator':'or','rules':[{'event_sources':[{'id':'<appID>','type':'app'}],'retention_seconds':8400,'filter':{'operator':'and','filters':[{'field':'event','operator':'eq','value':'fb_mobile_purchase'}]}}]}},
  'prefill': '1',
}
print AdAccount(id).create_custom_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).createCustomAudience()
      .setName(\"My Test Website Custom Audience\")
      .setRule(\"{\\"inclusions\\":{\\"operator\\":\\"or\\",\\"rules\\":[{\\"event_sources\\":[{\\"id\\":\\"<appID>\\",\\"type\\":\\"app\\"}],\\"retention_seconds\\":8400,\\"filter\\":{\\"operator\\":\\"and\\",\\"filters\\":[{\\"field\\":\\"event\\",\\"operator\\":\\"eq\\",\\"value\\":\\"fb_mobile_purchase\\"}]}}]}}\")
      .setPrefill(true)
      .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)
customaudiences = ad_account.customaudiences.create({
    name: 'My Test Website Custom Audience',
    rule: {'inclusions':{'operator':'or','rules':[{'event_sources':[{'id':'<appID>','type':'app'}],'retention_seconds':8400,'filter':{'operator':'and','filters':[{'field':'event','operator':'eq','value':'fb_mobile_purchase'}]}}]}},
    prefill: '1',
})

Esto devuelve el id del público si se realiza correctamente. Estos parámetros son los más relevantes:

Cada cuenta publicitaria puede crear 200 públicos personalizados como máximo desde la app para celulares. Haz una solicitud HTTP POST a:

https://graph.facebook.com/<API_VERSION>/act_<AD_ACCOUNT_ID>/customaudiences

Usa los siguientes campos:

Reglas del público

Para determinar quién se agrega al público personalizado, define una regla basada en los eventos de la aplicación. Una regla es un objeto JSON con pares clave-valor y puede hacer referencia a varios eventos de la aplicación. Se puede definir la regla sobre eventos específicos y sus parámetros, y también su agregación. Consulta Reglas del público para obtener más información. Consulta también:

• Sintaxis de las reglas de público
• Sintaxis de configuración de regla
• Sintaxis de las reglas de inclusión y exclusión: En event_sources, fija id en tu identificador de la app y type en app.
• Filtros
• Reglas de filtro:

  • Usa 'event' como field si el filtro es para especificar un evento. Parámetros que coinciden con eventos de la aplicación enviados por la aplicación, por ejemplo, "_appVersion", "_value", etc.
  • Si el atributo field está configurado como "event", el valor debe configurarse con el nombre de un evento. Utiliza la API de eventos de la app para ver eventos y parámetros de la app que reportó el píxel.
• Funciones de agregación: Las siguientes funciones de agregación están disponibles para los públicos personalizados de la app para celulares: "count","sum", "avg", "min" y "max".

Ejemplo de reglas de público personalizado de la app para celulares

Ejemplo de evento estándar

Todos los compradores de apps para celulares de los últimos 30 días con el identificador de la app 55064006:

{
    "inclusions: {
        "operator": "or",
        "rules": [    
            {
                "event_sources": [
                    {
                        "id": 55064006, 
                        "type": "app"
                    }
                ],
                "retention_seconds: 2592000,
                "filter": {
                    "operator": "and",
                    "filters": [
                        {
                            "field": "event",
                            "operator": "=",
                            "value": "fb_mobile_purchase"
                        }
                    ]
                }
            }
        ]
    }
}

Ejemplo de evento personalizado con parámetros

Todos los usuarios que devolvieron eventos personalizados “timeOnPanel” en los últimos 30 días con el identificador de app 55064006:

{
    "inclusions: {
        "operator": "or",
        "rules": [    
            {
                "event_sources": [
                    {
                        "id": 55064006, 
                        "type": "app"
                    }
                ],
                "retention_seconds: 2592000,
                "filter": {
                    "operator": "and",
                    "filters": [
                        {
                            "field": "event",
                            "operator": "=",
                            "value": "timeOnPanel"
                        }
                    ]
                }
            }
        ]
    }
}

Todos los usuarios que devolvieron eventos personalizados “timeOnPanel” en los que el valor del evento es mayor que 30, el color es “red” o “blue”, y el postre favorito incluye “banana”:

{
    "inclusions: {
        "operator": "or",
        "rules": [    
            {
                "event_sources": [
                    {
                        "id": 55064006, 
                        "type": "app",
                    }
                ],
                "retention_seconds: 2592000,
                "filter": {
                    "operator": "and",
                    "filters": [
                        {
                            "field": "event",
                            "operator": "=",
                            "value": "timeOnPanel",
                        },
                        {
                            "field": "_value",
                            "operator": ">",
                            "value": 30,
                        },
                        {
                            "field": "color",
                            "operator": "is_any",
                            "value": ["red", "blue"],
                        },
                        {
                            "field": "favoriteDessert",
                            "operator": "contains",
                            "value": "banana",
                        }
                    ]
                }
            }
        ]
    }
}

Ejemplo de agregación

El 20% más importante de compradores según las compras realizadas en los últimos 30 días:

{
    "inclusions: {
        "operator": "or",
        "rules": [    
            {
                "event_sources": [
                    {
                        "id": 55064006, 
                        "type": "app"
                    }
                ],
                "retention_seconds: 2592000,
                "filter": {
                    "operator": "and",
                    "filters": [
                        {
                            "field": "event",
                            "operator": "=",
                            "value": "fb_mobile_purchase"
                        }
                    ]
                }
                "aggregation": {
                    "type": "count",
                    "method": "percentile",
                    "operator": "in_range",
                    "from": 75,  
                    "to": 100,
                }
            }
        ]
    }
}

Ejemplo de exclusiones

Incluye a las personas que agregaron artículos al carrito pero no hicieron compras:

{
    "inclusions: {
        "operator": "or",
        "rules": [    
            {
                "event_sources": [
                    {
                        "id": 55064006, 
                        "type": "app"
                    }
                ],
                "retention_seconds: 2592000,
                "filter": {
                    "operator": "and",
                    "filters": [
                        {
                            "field": "event",
                            "operator": "=",
                            "value": "add_to_cart"
                        }
                    ]
                }
            }
        ]
    },
    "exclusions": {
        "operator": "or",
        "rules": [    
            {
                "event_sources": [
                    {
                        "id": 55064006, 
                        "type": "app"
                    }
                ],
                "retention_seconds: 2592000,
                "filter": {
                    "operator": "and",
                    "filters": [
                        {
                            "field": "event",
                            "operator": "=",
                            "value": "fb_mobile_purchase"
                        }
                    ]
                }
            }
        ]
    }
}

API de eventos de la app

Permite consultar cuáles son los eventos y parámetros de la app reportados a Facebook por una aplicación. Estos eventos y parámetros se pueden utilizar directamente para crear públicos personalizados. Se necesita un token de acceso asociado a app_id con rol de administrador, desarrollador o anunciante.

Haz una solicitud GET:

https://graph.facebook.com/<API_VERSION>/<APP_ID>/app_event_types

Como respuesta, se obtiene el objeto JSON que contiene una matriz data de diccionarios JSON que incluyen estos campos:

Administrar públicos

• Para obtener información sobre tu público, consulta Público personalizado, Lectura.
• Para actualizar, consulta Público personalizado, Actualización.
• Para eliminar, consulta Público personalizado, Eliminación.

Recursos

• Apps de iOS, Resegmentación con eventos de la app: volver a interactuar con usuarios en la app de iOS.
• Aplicaciones Android, Resegmentación con eventos de la aplicación: retargeting de anuncios en la app de Android.
• Segmentación de público personalizado
• Segmentación de público similar
• Referencia, Especificaciones de segmentación
• Referencia, Anuncios sobre apps para celulares para interacción