Experiências instantâneas

As experiências instantâneas são um destino de anúncios de tela cheia e pós-clique carregado quase instantaneamente em anúncios no Feed.

Antes de começar

Para criar e gerenciar experiências instantâneas, você precisa do seguinte:

• A permissão pages_manage_ads
• A permissão pages_read_engagement
• A permissão pages_show_list
• Capacidade de executar a tarefa ADVERTISE na Página

Limitações

• Só é possível atualizar uma experiência instantânea não publicada.
• A API de Experiências Instantâneas está disponível para o Instagram de forma limitada.
• Os anúncios das experiências instantâneas não são compatíveis com o Facebook Stories.

Criar

Para criar uma experiência instantânea, você precisa da identificação de uma Página do Facebook (PAGE-ID) e elementos que queira incluir na experiência, como fotos, botões e texto.

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(
  '/' . <PAGE_ID> . '/canvases',
  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/<PAGE_ID>/canvases

Elementos

Excluir um elemento

Para fazer a exclusão, envie uma solicitação DELETE com a identificação do elemento a ser removido.

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>

Obter experiências instantâneas existentes

Para obter informações sobre uma experiência instantânea, você precisa da identificação dela (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>

Obter todas as experiências instantâneas de uma Página

Para obter informações sobre todas as experiências instantâneas existentes de uma Página do Facebook, você precisa da identificação da Página (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

Atualizar uma experiência instantânea

Não é possível atualizar uma experiência instantânea já publicada. Além disso, você precisa da identificação correspondente (CANVAS-ID) e dos IDs dos elementos para atualização.

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 um modelo

Você pode usar um modelo como uma forma rápida de criar uma experiência instantânea para uma meta de negócios específica. O layout de cada modelo é fixo. No entanto, você pode substituir o conteúdo-padrão por imagens, vídeos, produtos, texto e links próprios.

Obter tipos de elemento de um modelo

Etapa 1: obter as informações de documento do modelo

Envie uma solicitação GET para identificar os elementos necessários a um modelo específico (no exemplo a seguir, Obter novos clientes).

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

Exemplo de resposta

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

Etapa 2: obter os tipos de elemento

Use a identificação do campo document para obter os elementos disponíveis a um modelo específico.

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

A lista retornada exibe tipos de elementos disponíveis para uso no modelo Obter novos 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 seu anúncio de experiência instantânea, envie uma solicitação POST à identificação da experiência (CANVAS-ID) e defina o campo is_published como 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>

Gerar um criativo do anúncio

Use o link de uma experiência instantânea existente (CANVAS-LINK) para gerar um criativo do anúncio.

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

Assim que o criativo do anúncio estiver pronto, você poderá criar o grupo, o conjunto e a campanha de anúncios.

Diálogo de anúncios das experiências instantâneas

Use o diálogo de anúncios de experiências instantâneas para fornecer as interfaces do usuário para a criação de anúncios de experiências instantâneas do Facebook no seu site. Para mais detalhes sobre o componente de interface do usuário, consulte Diálogos.

Para configurar o SDK do Facebook para JavaScript, consulte:

• Guia de início rápido
• Referência de inicialização

O SDK para JavaScript depende das permissões do usuário conectado para criar uma experiência instantânea. Se o usuário não tiver as permissões necessárias para criar uma experiência instantânea para a página e a empresa fornecidas, o diálogo exibirá um erro. Para garantir que não ocorram erros, o usuário deve estar na empresa e ter permissões de "criar anúncios" para a página.

Depois, acione o diálogo:

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

É possível fornecer as seguintes configurações para o plugin:

O parâmetro canvas_id é opcional e permite que um usuário edite ou visualize uma experiência instantânea existente. Não será possível editar experiências instantâneas concluídas. Para visualizar uma experiência instantânea, recomendamos usar o diálogo de experiências instantâneas.

Se a operação for bem-sucedida, o plugin retornará a seguinte resposta:

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

A identificação retornada é uma experiência instantânea publicada. Você pode usá-la em campanhas de anúncios. Se nenhuma resposta ou uma resposta undefined for retornada, isso será uma indicação de que o usuário fechou o diálogo antes de concluir a experiência instantânea. O usuário pode ter salvado a experiência instantânea, mas não a concluiu. Você pode extrair todas as experiências instantâneas pertencentes a uma página por meio da Graph API. Dessa forma, é possível verificar se há experiências inacabadas.

Ver prévia da experiência instantânea

API de Prévia do Iframe

Você pode gerar a visualização de uma experiência instantânea fazendo uma chamada da API de prévia que retorna um iframe (assim como na API de prévia do anúncio):

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

A API retorna algo semelhante a isto, que pode ser visualizado incorporando o elemento iframe retornado em 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 do Facebook

Você pode usar esse diálogo para fornecer a um usuário do Facebook a prévia de uma experiência instantânea no seu site. Para mais detalhes sobre o componente de interface do usuário, consulte Diálogos.

Para configurar o SDK do Facebook para JavaScript, consulte:

• Guia de início rápido
• Referência de inicialização

O SDK para JavaScript depende das permissões do usuário conectado para criar uma Experiência Instantânea. Se o usuário não tiver as permissões necessárias para visualizar a experiência instantânea, o diálogo exibirá um erro.

Depois, acione o diálogo de prévia:

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

É possível fornecer as seguintes configurações para o plugin:

Criar públicos para experiências instantâneas

Para criar um público de engajamento, isto é, um público de pessoas que interagiram com uma experiência instantânea, defina o parâmetro object_id do campo rule como a identificação da experiência instantânea (CANVAS-ID) na sua chamada POST /act_AD-ACCOUNT/customaudiences.

Pessoas que abriram a experiência 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

Pessoas que clicaram em qualquer link na experiência 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

Para obter mais informações sobre Públicos Personalizados, consulte a referência Público Personalizado.

Experiências instantâneas e anúncios do Instagram

A implementação de anúncios de experiências instantâneas com o Instagram usa as mesmas chamadas de API utilizadas para esse tipo de anúncio no Facebook. Observe que há limitações quando você usa o Instagram e as experiências instantâneas:

• Posicionamento – disponível para o Feed do Instagram e o Instagram Stories. Se selecionar o Instagram Stories, você deverá escolhê-lo como posicionamento de anúncios exclusivo.
• Elementos da experiência instantânea – totalmente compatíveis com cabeçalhos e conjuntos de produtos.

Oferecemos suporte parcial a estes elementos da experiência instantânea no Instagram:

• Rodapé – sem swipe to open em clientes, será renderizado como Tap to open.
• Carrossel – sem foto que vincule a outra experiência instantânea; no cliente aparece como um link não clicável. Para fotos e vídeos, sem ajustar à altura e à largura nem inclinar para fazer uma panorâmica; será renderizado como ajustar à largura.
• Botão – não é possível vincular a outra experiência instantânea ou à App Store.
• Texto – sem suporte à linguagem RTL.
• Vídeo – sem vídeo 360.
• Localizador de lojas – não é compatível.

Informações sobre anúncios

Confira os Insights sobre Anúncios para obter uma visão geral e descrições das métricas disponíveis.

Veja também

• Guia de anúncios do Facebook: Especificações de experiências instantâneas
• Central de Ajuda para Empresas: Saiba mais sobre as experiências instantâneas