Experiencias instantáneas

Las experiencias instantáneas ofrecen a las personas un destino de anuncio de pantalla completa posterior al clic que se carga de forma casi inmediata desde los anuncios del feed.

Antes de empezar

Para crear y administrar experiencias instantáneas, necesitarás lo siguiente:

• El permiso pages_manage_ads
• El permiso pages_read_engagement
• El permiso pages_show_list
• Poder realizar tareas ADVERTISE en la página

Limitaciones

• Solo puedes actualizar experiencias instantáneas sin publicar.
• La API de experiencias instantáneas está disponible para Instagram de manera limitada.
• En Facebook Stories, no se admiten los anuncios que utilizan experiencias instantáneas.

Crear

Para crear una experiencia instantánea, necesitarás el identificador de una página de Facebook (PAGE-ID) y cualquier elemento, como fotos, botones y texto, que quieras incluir en la experiencia.

Elementos

Eliminar un elemento

Para borrar un elemento, envía una solicitud DELETE con el identificador del elemento que deseas eliminar.

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;

$data = Api::instance()->call(
  '/' . <CANVAS_ELEMENT_ID>,
  RequestInterface::METHOD_DELETE,
  array())->getContent();

curl -X DELETE \
  -d 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<CANVAS_ELEMENT_ID>

Obtener una experiencia instantánea existente

Para obtener información sobre una experiencia instantánea existente, necesitarás el identificador de esta (CANVAS-ID).

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;

$params = array(
  'fields' => array(
    'body_elements',
    'canvas_link',
    'id',
    'is_hidden',
    'is_published',
    'name',
  ),
);

$data = Api::instance()->call(
  '/' . <CANVAS_ID>,
  RequestInterface::METHOD_GET,
  $params)->getContent();

curl -G \
  --data-urlencode 'fields=[ 
    "body_elements", 
    "canvas_link", 
    "id", 
    "is_hidden", 
    "is_published", 
    "name" 
  ]' \
  -d 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<CANVAS_ID>

Obtener todas las experiencias instantáneas de una página

Para obtener información sobre todas las experiencias instantáneas existentes de una página de Facebook, necesitarás el identificador de esta (PAGE-ID).

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;

$params = array(
  'fields' => array(
    'background_color',
    'body_elements',
    'canvas_link',
    'id',
    'is_hidden',
    'is_published',
    'last_editor',
    'name',
    'owner',
    'update_time',
  ),
);

$data = Api::instance()->call(
  '/' . <PAGE_ID> . '/canvases',
  RequestInterface::METHOD_GET,
  $params)->getContent();

curl -G \
  --data-urlencode 'fields=[ 
    "background_color", 
    "body_elements", 
    "canvas_link", 
    "id", 
    "is_hidden", 
    "is_published", 
    "last_editor", 
    "name", 
    "owner", 
    "update_time" 
  ]' \
  -d 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<PAGE_ID>/canvases

Actualizar una experiencia instantánea

Para actualizar una experiencia instantánea, se debe anular la publicación de esta. También necesitarás el identificador de la experiencia instantánea (CANVAS-ID) y cualquier identificador de elementos que desees actualizar.

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;

$params = array(
  'background_color' => 'FFFFFF',
  'body_element_ids' => array(<CANVAS_PHOTO_ID>),
  'is_hidden' => false,
  'is_published' => false,
  'name' => 'Canvas Name',
);

$data = Api::instance()->call(
  '/' . <CANVAS_ID>,
  RequestInterface::METHOD_POST,
  $params)->getContent();

curl \
  -F 'background_color=FFFFFF' \
  -F 'body_element_ids=["<CANVAS_PHOTO_ID>"]' \
  -F 'is_hidden=' \
  -F 'is_published=' \
  -F 'name=Canvas Name' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<CANVAS_ID>

Usar una plantilla

Puedes usar una plantilla como una forma rápida de crear una experiencia instantánea para un objetivo comercial específico. Aunque el diseño para cada plantilla es fijo, puedes reemplazar el contenido predeterminado con tus propias imágenes, videos, productos, textos y enlaces.

Obtener tipos de elementos para una plantilla

Paso 1: Obtener información del documento para la plantilla

Envía una solicitud GET a fin de definir los elementos necesarios para una plantilla en particular; en el siguiente ejemplo, Captar nuevos clientes.

curl -i -X GET \
 "https://graph.facebook.com/VERSION/133471657203838?fields=document&access_token=ACCESS-TOKEN"

Ejemplo de respuesta

{
  "document": {
    "name": "Get New Customers",
    "id": "397246414010297"
  },
  "id": "133471657203838"
}

Paso 2: Obtener los tipos de elementos

Usa el identificador para el campo document a fin de obtener elementos específicos disponibles para una plantilla en particular.

curl -i -X GET \
 "https://graph.facebook.com/VERSION/397246414010297?fields=body_elements&access_token=ACCESS-TOKEN"

En la lista devuelta se muestran tipos de elementos disponibles que se pueden usar en la plantilla Captar nuevos clientes.

    {
  "body_elements": [
    {
      "name": "Cover Image or Video",
      "element_type": "PHOTO",
      "id": "397271930674412"
    },
    {
      "name": "Text",
      "element_type": "RICH_TEXT",
      "id": "397271920674413"
    },
    {
      "name": "Text",
      "element_type": "RICH_TEXT",
      "id": "397271910674414"
    },
    {
      "name": "Button",
      "element_type": "BUTTON",
      "id": "397271914007747"
    },
    {
      "name": "Carousel",
      "element_type": "CAROUSEL",
      "id": "397271940674411"
    },
    {
      "name": "Text",
      "element_type": "RICH_TEXT",
      "id": "397271917341080"
    },
    {
      "name": "Button",
      "element_type": "BUTTON",
      "id": "397271924007746"
    }
  ],
  "id": "397246414010297"
}

Publicar

Para publicar tu anuncio de experiencia instantánea, envía una solicitud POST a tu identificador de experiencia instantánea (CANVAS-ID) y fija el campo is_published en el valor true.

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;

$params = array(
  'is_published' => true,
);

$data = Api::instance()->call(
  '/' . <CANVAS_ID>,
  RequestInterface::METHOD_POST,
  $params)->getContent();

curl \
  -F 'is_published=1' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<CANVAS_ID>

Crear contenido para un anuncio

Crea contenido de anuncios usando el enlace para una experiencia instantánea preexistente (CANVAS-LINK).

curl -X POST \
  -F 'image_hash="<IMAGE_HASH>"' \
  -F 'object_story_spec={
       "page_id": "<PAGE_ID>",
       "link_data": {
         "image_hash": "<IMAGE_HASH>",
         "link": "<CANVAS_LINK>",
         "name": "Creative message",
         "call_to_action": {
           "type": "LEARN_MORE"
         }
       }
     }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v20.0/act_<AD_ACCOUNT_ID>/adcreatives

'use strict';
const bizSdk = require('facebook-nodejs-business-sdk');
const AdAccount = bizSdk.AdAccount;
const AdCreative = bizSdk.AdCreative;

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 = {
  'image_hash' : '<imageHash>',
  'object_story_spec' : {'page_id':'<pageID>','link_data':{'image_hash':'<imageHash>','link':'<canvasURI>','name':'Creative message','call_to_action':{'type':'LEARN_MORE'}}},
};
const adcreatives = (new AdAccount(id)).createAdCreative(
  fields,
  params
);
logApiCallResult('adcreatives api call complete.', adcreatives);

require __DIR__ . '/vendor/autoload.php';

use FacebookAds\Object\AdAccount;
use FacebookAds\Object\AdCreative;
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(
  'image_hash' => '<imageHash>',
  'object_story_spec' => array('page_id' => '<pageID>','link_data' => array('image_hash' => '<imageHash>','link' => '<canvasURI>','name' => 'Creative message','call_to_action' => array('type' => 'LEARN_MORE'))),
);
echo json_encode((new AdAccount($id))->createAdCreative(
  $fields,
  $params
)->exportAllData(), JSON_PRETTY_PRINT);

from facebook_business.adobjects.adaccount import AdAccount
from facebook_business.adobjects.adcreative import AdCreative
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 = {
  'image_hash': '<imageHash>',
  'object_story_spec': {'page_id':'<pageID>','link_data':{'image_hash':'<imageHash>','link':'<canvasURI>','name':'Creative message','call_to_action':{'type':'LEARN_MORE'}}},
}
print AdAccount(id).create_ad_creative(
  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).createAdCreative()
      .setImageHash(\"<imageHash>\")
      .setObjectStorySpec(
          new AdCreativeObjectStorySpec()
            .setFieldLinkData(
              new AdCreativeLinkData()
                .setFieldCallToAction(
                  new AdCreativeLinkDataCallToAction()
                    .setFieldType(AdCreativeLinkDataCallToAction.EnumType.VALUE_LEARN_MORE)
                )
                .setFieldImageHash(\"<imageHash>\")
                .setFieldLink(\"<canvasURI>\")
                .setFieldName(\"Creative message\")
            )
            .setFieldPageId(\"<pageID>\")
        )
      .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)
adcreatives = ad_account.adcreatives.create({
    image_hash: '<imageHash>',
    object_story_spec: {'page_id':'<pageID>','link_data':{'image_hash':'<imageHash>','link':'<canvasURI>','name':'Creative message','call_to_action':{'type':'LEARN_MORE'}}},
})

Una vez que esté listo el contenido de anuncios, podrás crear el grupo, el conjunto y la campaña.

Cuadro de diálogo de anuncios de experiencias instantáneas

Puedes usar el cuadro de diálogo de anuncios de experiencias instantáneas a fin de incluir en el sitio web las interfaces de usuario para la creación de anuncios de experiencias instantáneas de Facebook. Para obtener información sobre el componente de UI, consulta Cuadros de diálogo.

Para configurar el SDK de Facebook para JavaScript, consulta:

• Guía de inicio rápido
• Referencia de inicialización

El SDK para JavaScript utiliza los permisos del usuario que inició sesión para crear una experiencia instantánea. Si el usuario no cuenta con los permisos necesarios para crear una experiencia instantánea para la página y el negocio proporcionados, el cuadro de diálogo mostrará un error. Para evitar errores, el usuario debe estar en la empresa y tener permisos de creación de anuncios para la página.

Luego, activa el cuadro de diálogo:

FB.ui({         
  display: 'popup',
  method: 'instant_experiences_builder',
  business_id: '<BUSINESS_ID>',
  page_id: '<PAGE_ID>'
}, function(response) {
  // callback
});

Puedes proporcionar esta configuración para el plugin:

El parámetro canvas_id es opcional y se usa para permitir a un usuario editar una experiencia instantánea preexistente u obtener una vista previa de ella. Si una experiencia instantánea está completa, no puedes editarla. Para obtener una vista previa de una experiencia instantánea, te recomendamos usar el cuadro de diálogo de vista previa de experiencias instantáneas.

Si la operación se realiza con éxito, el plugin proporciona esta respuesta:

{
  "success": true,
  "id": "CANVAS-ID"
}

El identificador que se devuelve es una experiencia instantánea publicada. Ya puedes usarlo en campañas de anuncios. Si no se recibe una respuesta, o si se recibe una respuesta undefined, significa que el usuario cerró el cuadro de diálogo antes de finalizar la experiencia instantánea. El usuario puede haber guardado la experiencia instantánea, pero no la finalizó. Puedes usar la API Graph para ver una lista de todas las experiencias instantáneas que pertenecen a una página y determinar si hay alguna que no esté finalizada.

Obtener una vista previa de una experiencia instantánea

API de vistas previas de iframe

Puede generar una vista previa de una experiencia instantánea si llamas a la API de vistas previas, que devuelve un iframe, similar a lo que sucede con la API de vistas previas de anuncios:

curl -X GET \
  -d 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v18.0/<CANVAS_ID>/preview
  
Open In Graph API Explorer

La API devuelve un elemento como este, que se puede ver si se inserta el elemento de iframe devuelto en HTML:

{
"data": [
    {
      "body": "<iframe src=\"https://www.facebook.com/ads/canvas/preview?d=AQKELApdJxoVp2f3PHl8-pRtYuAh4-_eDupMDbh-pS9zde_EFxckhYQCXu7NYUi4PhhBA7uskIo2Ys3IjIVNGZiS&t=AQKGOPqGI-NWcv1YKbA\" width=\"405\" height=\"720\" scrolling=\"yes\" style=\"border: none;\"></iframe>"
    }
  ],
  "__www_request_id__": "AQnyr47Qp2r5M-ISqSiMgrw"
}

SDK de Facebook

Puedes usar este cuadro de diálogo para obtener la vista previa de una experiencia instantánea como la vería un usuario de Facebook desde tu sitio web. Para obtener información sobre el componente de UI, consulta Cuadros de diálogo.

Para configurar el SDK de Facebook para JavaScript, consulta lo siguiente:

• Guía de inicio rápido
• Referencia de inicialización

El SDK para JavaScript utiliza los permisos del usuario que inició sesión para crear una experiencia instantánea. Si el usuario no tiene los permisos necesarios para ver la experiencia instantánea, el cuadro de diálogo muestra un error.

Luego, activa el cuadro de diálogo de vista previa:

FB.ui({         
  display: 'popup',
  method: 'instant_experiences_preview',
  canvas_id: 'CANVAS-ID'
});

Puedes proporcionar esta configuración para el plugin:

Crear públicos para experiencias instantáneas

Para crear un público activo, un público que haya interactuado con una experiencia instantánea, fija el parámetro object_id del campo rule en el identificador de experiencia instantánea (CANVAS-ID) en tu llamada a POST /act_AD-ACCOUNT/customaudiences.

Personas que abrieron la experiencia instantánea

    curl \
    	-F 'name=Instant Experience Engagement Audience' \
    	-F 'description=People who opened this Instant Experience' \
    	-F 'rule=[{"object_id":"<CANVAS_ID>","event_name":"instant_shopping_document_open"}]' \
    	-F 'access_token=<ACCESS_TOKEN>' \  
    https://graph.facebook.com/<VERSION>/act_<AD_ACCOUNT_ID>/customaudiences
Open In Graph API Explorer

Personas que hicieron clic en algún enlace de la experiencia instantánea

    curl \
    	-F 'name=Instant Experience Engagement Audience' \
    	-F 'description=People who clicked any links in this Instant Experience' \
    	-F 'rule=[{"object_id":"<CANVAS_ID>","event_name":"instant_shopping_element_click"}]' \
    	-F 'access_token=<ACCESS_TOKEN>' \  
    https://graph.facebook.com/<VERSION>/act_<AD_ACCOUNT_ID>/customaudiences
Open In Graph API Explorer

Para obtener más información sobre los públicos personalizados, consulta Referencia de público personalizado.

Anuncios de Instagram y experiencias instantáneas

La implementación de las experiencias instantáneas con Instagram usa las mismas llamadas a la API que se usan para la experiencia instantánea en Facebook. Ten en cuenta que existen limitaciones cuando usas Instagram y experiencias instantáneas:

• Ubicaciones: está disponible para las noticias de Instagram e Instagram Stories. Si seleccionas Instagram Stories, debes seleccionar esta como tu ubicación de anuncios exclusiva.
• Elementos de experiencia instantánea: se admiten totalmente los encabezados y los conjuntos de productos.

Admitimos parcialmente estos elementos de experiencia instantánea en Instagram:

• Pie de página: no admite swipe to open. En los clientes, se muestra como Tap to open.
• Secuencia: no admite fotos que dirijan a otra experiencia instantánea. En los clientes, aparece como un enlace en el que no se puede hacer clic. Para las fotos y los videos, no admite las opciones de ajustar a la altura, ajustar al ancho ni inclinar para panorámica. Esto se muestra como ajustar el ancho.
• Botón: no puede dirigir a otra experiencia instantánea ni a la tienda de aplicaciones.
• Texto: no admite idiomas que se escriben de derecha a izquierda.
• Video: no admite videos 360°.
• Localizadores de tiendas: no se admiten.

Estadísticas de anuncios

Para obtener información general y descripciones de las métricas disponibles, consulta Estadísticas de anuncios.

Más información

• Guía de anuncios de Facebook: Especificaciones de experiencias instantáneas
• Servicio de ayuda para empresas Información sobre experiencias instantáneas