Anúncios de app

Este documento descreve várias unidades de anúncio desenvolvidas para impulsionar mais instalações e engajamento com apps para celular e computador.

Use essa unidade de anúncio se quiser atrair pessoas ao seu app para desktop ou celular para fins de instalação ou engajamento via foto, vídeo, carrossel ou criativos interativos.

Em termos conceituais, isso possibilita os seguintes anúncios:

Foto Vídeo Carrossel Reproduzíveis

Anúncio de instalação de app para celular

Anúncio de engajamento de app para celular

Anúncio de instalação para desktop

Anúncio de envolvimento para desktop

Anúncios de app para desktop de mercadorias virtuais

Os anúncios de app para desktop de mercadorias virtuais são um subconjunto do engajamento para desktop. Você pode usar ofertas de mercadorias virtuais para retomar o engajamento e convencer os pagantes a usar o app novamente. Por exemplo, um app pode oferecer desconto em um item ou um conjunto da moeda no app em um feed para envolver novamente os antigos clientes. Veja como configurar o app para aceitar pagamentos aqui.

Para sua referência, a unidade com a imagem de instalação no app para celular é assim:

O anúncio de app para desktop de mercadorias virtuais com imagem é assim:

Pré-requisitos

  • Para criar um anúncio de app, o desenvolvedor deverá concluir as etapas deste tutorial.
  • O anunciante deve ter uma Página do Facebook por meio da qual veiculará esses anúncios.

Criar

Ao criar o anúncio, observe os seguintes requisitos:

  • O objetivo da campanha deve ser APP_INSTALLS, LINK_CLICKS ou CONVERSIONS.
  • Para anúncios de app para celular, é obrigatório usar o campo user_os da especificação de direcionamento móvel. O posicionamento deve ter um campo device_platforms com o valor ["mobile"] e recomendar o uso dos outros campos da especificação para fazer o direcionamento de dispositivos móveis no Facebook. Opcionalmente, se quiser usar somente certas plataformas, você poderá especificar publisher_platforms.
  • Para anúncios de app de canvas, device_platforms deve ser desktop. Opcionalmente, será possível especificar facebook_positions se você não quiser o Feed nem a coluna do lado direito do Facebook para desktop.
  • Em caso de uso de GET_OFFER para mercadorias virtuais, deverá haver desconto no preço. Consulte a documentação sobre mercadorias virtuais para saber mais.

Chamadas para ação de anúncio de app:

As chamadas para ação adicionais listadas abaixo estão disponíveis para anúncios de app no campo call_to_action de uma publicação ou na object_story_spec de um criativo do anúncio. Você também pode especificar o deep link do app para celular no campo app_link ou o objeto de mercadoria virtual do app para desktop no campo product_link.

Chave Valor Obrigatório

type

Tipos de chamada para ação de dispositivos móveis independentemente de instalação ou de engajamento:
SHOP_NOW
BOOK_TRAVEL
LEARN_MORE
SIGN_UP
DOWNLOAD
INSTALL_MOBILE_APP
USE_MOBILE_APP
WATCH_VIDEO
WATCH_MORE
OPEN_LINK
Tipos de chamada para ação de instalação ou engajamento para computador:
USE_APP (apps para computador)
PLAY_GAME (apps de jogos para desktop)
Tipos de chamada para ação para anúncios de app para desktop de mercadorias virtuais:
BUY_NOW
GET_OFFER

Sim.

value

Dicionário JSON de {"link": "<APP_STORE_LINK>","app_link": "<MOBILE_DEEP_LINK>","product_link": "<VIRTUAL_GOOD_DEEP_LINK>","link_title": "<NAME_FOR_LINK>"}

Sim.

  • Apenas alguns valores são obrigatórios.

value.link

Faz referência a App Store, Google Play Store ou URL do app Canvas do Facebook, por exemplo: https://itunes.apple.com/br/app/facebook/id284882215

Sim.

value.app_link

Definir o destino do deep link somente para apps para celular, por exemplo, myapp://product/12345. Para especificar um deep link de apps para computador, determine-o diretamente no campo de link de URL.

Sim, apenas para anúncios de engajamento ou de instalação de app para celular.

value.product_link

Para definir a URL que aponta para o objeto da mercadoria virtual Open Graph do produto. Saiba mais sobre os detalhes da configuração aqui.

Sim, somente para mercadorias virtuais para desktop.

value.link_title

Permite personalizar o nome do link, que será exibido sob a imagem do anúncio.

Não.

Especificação de campos

Criar com foto

Para criar um anúncio de app para celular ou desktop com uma foto, primeiro faça uma publicação de link na Página com uma foto por meio do campo object_story_spec: {'link_data': ...} do criativo do anúncio.

Exemplo:

curl -X POST \
  -F 'name="Sample Creative"' \
  -F 'object_story_spec={
       "page_id": "<PAGE_ID>",
       "link_data": {
         "call_to_action": {
           "type": "INSTALL_MOBILE_APP",
           "value": {
             "link": "<APP_STORE_URL>"
           }
         },
         "image_hash": "<IMAGE_HASH>",
         "link": "<APP_STORE_URL>",
         "message": "Try it out"
       }
     }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v19.0/act_<AD_ACCOUNT_ID>/adcreatives

Como alternativa, você pode criar a publicação da Página por meio do ponto de extremidade do feed da Página e usar a identificação da publicação no criativo. Consulte abaixo a seção Exemplos para saber mais.

Para criar um anúncio de instalação do app para celular ou um anúncio de engajamento por meio do formato de anúncio em carrossel, siga as instruções nos documentos sobre anúncios em carrossel, mas especifique um link da loja de apps em cada campo link de child_attachments.

Considerações

  • No momento, os anúncios de app para celular em carrossel são compatíveis somente com um app.
  • Número mínimo de 3 imagens (em comparação com 2 nos anúncios em carrossel que não são de app).
  • Anúncios de app para celular em carrossel devem ter uma chamada para ação definida.
  • O cartão final (que normalmente mostra a foto de perfil da Página) não será exibido para anúncios de app para celular em carrossel.

É necessário especificar o mesmo link da loja de apps em cada child_attachment. Você não precisa especificar o link novamente em call_to_action:{'value':{'link':... }}}.

curl -X POST \
  -F 'name="Carousel app ad"' \
  -F 'object_story_spec={
       "page_id": "<PAGE_ID>",
       "link_data": {
         "message": "My message",
         "link": "http://www.example.com/appstoreurl",
         "caption": "WWW.ITUNES.COM",
         "name": "The link name",
         "description": "The link description",
         "child_attachments": [
           {
             "link": "http://www.example.com/appstoreurl",
             "image_hash": "<IMAGE_HASH>",
             "call_to_action": {
               "type": "USE_MOBILE_APP",
               "value": {
                 "app_link": "<DEEP_LINK>"
               }
             }
           },
           {
             "link": "http://www.example.com/appstoreurl",
             "image_hash": "<IMAGE_HASH>",
             "call_to_action": {
               "type": "USE_MOBILE_APP",
               "value": {
                 "app_link": "<DEEP_LINK>"
               }
             }
           },
           {
             "link": "http://www.example.com/appstoreurl",
             "image_hash": "<IMAGE_HASH>",
             "call_to_action": {
               "type": "USE_MOBILE_APP",
               "value": {
                 "app_link": "<DEEP_LINK>"
               }
             }
           },
           {
             "link": "http://www.example.com/appstoreurl",
             "image_hash": "<IMAGE_HASH>",
             "call_to_action": {
               "type": "USE_MOBILE_APP",
               "value": {
                 "app_link": "<DEEP_LINK>"
               }
             }
           }
         ],
         "multi_share_optimized": true
       }
     }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v19.0/act_<AD_ACCOUNT_ID>/adcreatives

Criar com vídeo

Para criar um anúncio de app com um vídeo, primeiro carregue o vídeo em questão na biblioteca de vídeos da conta de anúncios. Depois, use o ID do vídeo no campo object_story_spec: {'video_data':...} do criativo do anúncio.

Exemplo:

use FacebookAds\Object\AdCreative;
use FacebookAds\Object\AdCreativeVideoData;
use FacebookAds\Object\Fields\AdCreativeVideoDataFields;
use FacebookAds\Object\AdCreativeObjectStorySpec;
use FacebookAds\Object\Fields\AdCreativeObjectStorySpecFields;
use FacebookAds\Object\Fields\AdCreativeFields;

$video_data = new AdCreativeVideoData();
$video_data->setData(array(
  AdCreativeVideoDataFields::IMAGE_URL => '<THUMBNAIL_URL>',
  AdCreativeVideoDataFields::VIDEO_ID => <VIDEO_ID>,
  AdCreativeVideoDataFields::CALL_TO_ACTION => array(
    'type' => 'INSTALL_MOBILE_APP',
    'value' => array(
      'link' => '<APP_STORE_URL>',
    ),
  ),
));

$object_story_spec = new AdCreativeObjectStorySpec();
$object_story_spec->setData(array(
  AdCreativeObjectStorySpecFields::PAGE_ID => <PAGE_ID>,
  AdCreativeObjectStorySpecFields::VIDEO_DATA => $video_data,
));

$creative = new AdCreative(null, 'act_<AD_ACCOUNT_ID>');

$creative->setData(array(
  AdCreativeFields::NAME => 'Sample Creative',
  AdCreativeFields::OBJECT_STORY_SPEC => $object_story_spec,
));

$creative->create();
from facebookads.adobjects.adcreative import AdCreative
from facebookads.adobjects.adcreativeobjectstoryspec \
    import AdCreativeObjectStorySpec
from facebookads.adobjects.adcreativevideodata \
    import AdCreativeVideoData

video_data = AdCreativeVideoData()
video_data[AdCreativeVideoData.Field.description] = 'try it out'
video_data[AdCreativeVideoData.Field.video_id] = <VIDEO_ID>
video_data[AdCreativeVideoData.Field.image_url] = '<THUMBNAIL_URL>'
video_data[AdCreativeVideoData.Field.call_to_action] = {
    'type': 'INSTALL_MOBILE_APP',
    'value': {
        'link': '<APP_STORE_URL>',
        'link_title': 'Facebook',
    },
}

object_story_spec = AdCreativeObjectStorySpec()
object_story_spec[AdCreativeObjectStorySpec.Field.page_id] = <PAGE_ID>
object_story_spec[AdCreativeObjectStorySpec.Field.video_data] = video_data

creative = AdCreative(parent_id='act_<AD_ACCOUNT_ID>')
creative[AdCreative.Field.name] = 'Sample Creative'
creative[AdCreative.Field.object_story_spec] = object_story_spec
creative.remote_create()
AdCreative adCreative = new AdAccount(act_<AD_ACCOUNT_ID>, context).createAdCreative()
  .setName("Sample Creative")
  .setObjectStorySpec(
    new AdCreativeObjectStorySpec()
      .setFieldPageId(<PAGE_ID>)
      .setFieldVideoData(
        new AdCreativeVideoData()
          .setFieldCallToAction(
            new AdCreativeLinkDataCallToAction()
              .setFieldType(AdCreativeLinkDataCallToAction.EnumType.VALUE_INSTALL_MOBILE_APP)
              .setFieldValue(
                new AdCreativeLinkDataCallToActionValue()
                  .setFieldLink(<APP_STORE_URL>)
              )
          )
          .setFieldLinkDescription("try it out")
          .setFieldImageUrl(<THUMBNAIL_URL>)
          .setFieldVideoId(<VIDEO_ID>)
      )
  )
  .execute();
String ad_creative_id = adCreative.getId();
curl \
  -F 'name=Sample Creative' \
  -F 'object_story_spec={ 
    "page_id": "<PAGE_ID>", 
    "video_data": { 
      "call_to_action": {"type":"INSTALL_MOBILE_APP","value":{"link":"<APP_STORE_URL>"}}, 
      "image_url": "<THUMBNAIL_URL>", 
      "video_id": "<VIDEO_ID>" 
    } 
  }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/act_<AD_ACCOUNT_ID>/adcreatives

Como alternativa, você pode criar a publicação por meio do ponto de extremidade de vídeo da Página e usar o ID do vídeo no criativo. Consulte abaixo a seção Exemplos para saber mais.

Ler

Para recuperar detalhes sobre sua publicação da Página, consulte os documentos sobre publicação de link na Página ou publicação de vídeo na Página.

Você pode listar todas as publicações da borda /promotable_posts da Página.

curl https://graph.facebook.com/{API_VERSION}/{PAGE_ID}/promotable_posts

Para recuperar detalhes do seu criativo do anúncio, consulte a documentação sobre criativo do anúncio.

Antes de começar

Exemplo de código

"call_to_action={'type':'LEARN_MORE', 'value':{'link':'https://itunes.apple.com/us/app/facebook/id284882215', 'app_link':'facebook://path/to/page'}}"

Antes de especificar um link de app, é necessário confirmar se ele foi extraído. Para isso, faça a chamada a seguir:

https://graph.facebook.com/{API_VERSION}/?type=og&amp;scrape=true&amp;id={APP_LINK}

Insights sobre o app para celular

Os insights são aplicados somente a anúncios com um objeto promovido que contenha o ID do app. Para obter esse ID, inscreva o app no Facebook.

A Meta fornecerá insights diários agregados sobre os dados demográficos das pessoas que instalaram o app. Para recuperar esses dados, use um token de acesso ao app e faça a consulta:

https://graph.facebook.com/{API_VERSION}/{APP_ID}/insights/application_mobile_app_installs?&access_token={ACCESS_TOKEN}

Também é possível detalhar as estatísticas ao especificar um parâmetro adicional de URL, breakdown, equivalente a um dos valores a seguir. No momento, não é possível combinar detalhamentos.

Nome Descrição

gender_age

Detalhe suas estatísticas sobre idade e gênero do público.

country

Detalhe suas estatísticas sobre o país do público.

locale

Detalhe suas estatísticas sobre a localidade do público.

Exemplos:

https://graph.facebook.com/{API_VERSION}/{APP_ID}/insights/application_mobile_app_installs?breakdown=gender_age&amp;access_token={ACCESS_TOKEN}

https://graph.facebook.com/{API_VERSION}/{APP_ID}/insights/application_mobile_app_installs?breakdown=country&amp;access_token={ACCESS_TOKEN}

https://graph.facebook.com/{API_VERSION}/{APP_ID}/insights/application_mobile_app_installs?breakdown=locale&amp;access_token={ACCESS_TOKEN}

Exemplos

Criar um anúncio de imagem para instalação do app para celular

Etapa 1: crie a publicação da Página com a imagem. Lembre-se de que é necessário usar o PAGE_ACCESS_TOKEN e a sessão de API da Página para criar uma publicação.

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

$params = array(
  'message' => 'Sign up today',
  'picture' => '<IMAGE_URL>',
  'link' => '<LINK>',
  'published' => 1,
  'call_to_action' => array(
    'type' => 'SIGN_UP',
    'value' => array(
      'link' => '<LINK>',
    ),
  ),
);

$data = Api::instance()->call(
  '/'.<PAGE_ID>.'/feed',
  RequestInterface::METHOD_POST,
  $params)->getContent();
from facebookads import FacebookAdsApi

params = {
    'massage': 'Sign up today.',
    'picture': '<IMAGE_URL>',
    'link': '<LINK>',
    'published': 1,
    'call_to_action': {
        'type': 'SIGN_UP',
        'value': {
            'link': '<LINK>',
        },
    },
}

data = FacebookAdsApi.get_default_api().\
    call('POST', (<PAGE_ID>, 'feed'), params=params)
curl \
  -F 'message=Sign up today' \
  -F 'picture=<IMAGE_URL>' \
  -F 'link=<LINK>' \
  -F 'published=1' \
  -F 'call_to_action={"type":"SIGN_UP","value":{"link":"<LINK>"}}' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<PAGE_ID>/feed

Etapa 2: desenvolva o criativo do anúncio ({STORY_ID} está como '{PAGE_ID}_{POST_ID}').

curl -X POST \ -F 'object_story_id="<PAGE_ID>_<POST_ID>"' \ -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 = { 'object_story_id' : '<pageID>_<postID>', }; 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( 'object_story_id' => '<pageID>_<postID>', ); 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 = { 'object_story_id': '<pageID>_<postID>', } 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() .setObjectStoryId(\"<pageID>_<postID>\") .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({ object_story_id: '<pageID>_<postID>', })

Etapa 3: use o criativo em um anúncio.

curl -X POST \ -F 'name="My AdGroup with Redownload"' \ -F 'adset_id="<AD_SET_ID>"' \ -F 'creative={ "creative_id": "<CREATIVE_ID>" }' \ -F 'redownload=1' \ -F 'status="PAUSED"' \ -F 'access_token=<ACCESS_TOKEN>' \ https://graph.facebook.com/v19.0/act_<AD_ACCOUNT_ID>/ads
'use strict'; const bizSdk = require('facebook-nodejs-business-sdk'); const AdAccount = bizSdk.AdAccount; const Ad = bizSdk.Ad; 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 AdGroup with Redownload', 'adset_id' : '<adSetID>', 'creative' : {'creative_id':'<adCreativeID>'}, 'redownload' : '1', 'status' : 'PAUSED', }; const ads = (new AdAccount(id)).createAd( fields, params ); logApiCallResult('ads api call complete.', ads);
require __DIR__ . '/vendor/autoload.php'; use FacebookAds\Object\AdAccount; use FacebookAds\Object\Ad; 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 AdGroup with Redownload', 'adset_id' => '<adSetID>', 'creative' => array('creative_id' => '<adCreativeID>'), 'redownload' => '1', 'status' => 'PAUSED', ); echo json_encode((new AdAccount($id))->createAd( $fields, $params )->exportAllData(), JSON_PRETTY_PRINT);
from facebook_business.adobjects.adaccount import AdAccount from facebook_business.adobjects.ad import Ad 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 AdGroup with Redownload', 'adset_id': '<adSetID>', 'creative': {'creative_id':'<adCreativeID>'}, 'redownload': '1', 'status': 'PAUSED', } print AdAccount(id).create_ad( 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).createAd() .setName(\"My AdGroup with Redownload\") .setAdsetId(<adSetID>L) .setCreative( new AdCreative() .setFieldId(\"<adCreativeID>\") ) .setParam(\"redownload\", \"1\") .setStatus(Ad.EnumStatus.VALUE_PAUSED) .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) ads = ad_account.ads.create({ name: 'My AdGroup with Redownload', adset_id: '<adSetID>', creative: {'creative_id':'<adCreativeID>'}, redownload: '1', status: 'PAUSED', })

Criar um anúncio de imagem para app para celular com um deep link, otimizando-o para cliques e pagando por impressões

Etapa 1: crie a publicação da Página com a imagem. Lembre-se de que é necessário usar o PAGE_ACCESS_TOKEN e a sessão de API da Página para criar uma publicação.

curl -X POST \ -F 'message="This is a test message"' \ -F 'call_to_action={ "type": "BUY_NOW", "value": { "link": "{app-store-url}", "app_link": "{deep-link}" } }' \ -F 'access_token=<ACCESS_TOKEN>' \ https://graph.facebook.com/v19.0/{page-id}/feed
'use strict'; const bizSdk = require('facebook-nodejs-business-sdk'); const Page = bizSdk.Page; const PagePost = bizSdk.PagePost; const access_token = '<ACCESS_TOKEN>'; const app_secret = '<APP_SECRET>'; const app_id = '<APP_ID>'; const id = '<PAGE_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 = { 'message' : 'This is a test message', 'call_to_action' : {'type':'BUY_NOW','value':{'link':'<appLink>','app_link':'<deepLinkURL>'}}, }; const feed = (new Page(id)).createFeed( fields, params ); logApiCallResult('feed api call complete.', feed);
require __DIR__ . '/vendor/autoload.php'; use FacebookAds\Object\Page; use FacebookAds\Object\PagePost; use FacebookAds\Api; use FacebookAds\Logger\CurlLogger; $access_token = '<ACCESS_TOKEN>'; $app_secret = '<APP_SECRET>'; $app_id = '<APP_ID>'; $id = '<PAGE_ID>'; $api = Api::init($app_id, $app_secret, $access_token); $api->setLogger(new CurlLogger()); $fields = array( ); $params = array( 'message' => 'This is a test message', 'call_to_action' => array('type' => 'BUY_NOW','value' => array('link' => '<appLink>','app_link' => '<deepLinkURL>')), ); echo json_encode((new Page($id))->createFeed( $fields, $params )->exportAllData(), JSON_PRETTY_PRINT);
from facebook_business.adobjects.page import Page from facebook_business.adobjects.pagepost import PagePost from facebook_business.api import FacebookAdsApi access_token = '<ACCESS_TOKEN>' app_secret = '<APP_SECRET>' app_id = '<APP_ID>' id = '<PAGE_ID>' FacebookAdsApi.init(access_token=access_token) fields = [ ] params = { 'message': 'This is a test message', 'call_to_action': {'type':'BUY_NOW','value':{'link':'<appLink>','app_link':'<deepLinkURL>'}}, } print Page(id).create_feed( 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 = \"<PAGE_ID>\"; APIContext context = new APIContext(access_token).enableDebug(true); new Page(id, context).createFeed() .setMessage(\"This is a test message\") .setCallToAction(\"{\\"type\\":\\"BUY_NOW\\",\\"value\\":{\\"link\\":\\"<appLink>\\",\\"app_link\\":\\"<deepLinkURL>\\"}}\") .execute(); } }
require 'facebook_ads' access_token = '<ACCESS_TOKEN>' app_secret = '<APP_SECRET>' app_id = '<APP_ID>' id = '<PAGE_ID>' FacebookAds.configure do |config| config.access_token = access_token config.app_secret = app_secret end page = FacebookAds::Page.get(id) feed = page.feed.create({ message: 'This is a test message', call_to_action: {'type':'BUY_NOW','value':{'link':'<appLink>','app_link':'<deepLinkURL>'}}, })

Etapa 2: desenvolva o criativo do anúncio.

curl -X POST \ -F 'object_story_id="<PAGE_ID>_<POST_ID>"' \ -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 = { 'object_story_id' : '<pageID>_<postID>', }; 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( 'object_story_id' => '<pageID>_<postID>', ); 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 = { 'object_story_id': '<pageID>_<postID>', } 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() .setObjectStoryId(\"<pageID>_<postID>\") .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({ object_story_id: '<pageID>_<postID>', })

Etapa 3: defina os lances no conjunto de anúncios, otimizando para obter mais cliques e pagando por impressões.

use FacebookAds\Object\AdSet;
use FacebookAds\Object\Fields\AdSetFields;
use FacebookAds\Object\Values\AdSetBillingEventValues;
use FacebookAds\Object\Values\AdSetOptimizationGoalValues;
use FacebookAds\Object\Fields\TargetingFields;
use FacebookAds\Object\Targeting;

$adset = new AdSet(null, 'act_<AD_ACCOUNT_ID>');
$adset->setData(array(
  AdSetFields::NAME => 'LifetimeBudgetSet',
  AdsetFields::LIFETIME_BUDGET => 100000,
  AdSetFields::BID_AMOUNT => 500,
  AdSetFields::BILLING_EVENT => AdSetBillingEventValues::IMPRESSIONS,
  AdSetFields::OPTIMIZATION_GOAL => AdSetOptimizationGoalValues::LINK_CLICKS,
  AdSetFields::PROMOTED_OBJECT => array(
      'application_id' => <APP_ID>,
      'object_store_url' => '<APP_STORE_URL>',
  ),
  AdSetFields::TARGETING => (new Targeting())->setData(array(
    TargetingFields::GEO_LOCATIONS => array(
      'countries' => array('US'),
    ),
    TargetingFields::USER_OS => array(
      'IOS',
    ),
    TargetingFields::PUBLISHER_PLATFORMS => array(
      'facebook',
      'audience_network',

    ),
    TargetingFields::FACEBOOK_POSITIONS => array('feed'),
  )),
  AdSetFields::CAMPAIGN_ID => <CAMPAIGN_ID>,
  AdSetFields::END_TIME =>
    (new \DateTime("+1 week"))->format(\DateTime::ISO8601),
));

$adset->create(array(
  AdSet::STATUS_PARAM_NAME => AdSet::STATUS_PAUSED,
));
import time
from facebookads.adobjects.adset import AdSet

adset = AdSet(parent_id='act_<AD_ACCOUNT_ID>')
adset.update({
    AdSet.Field.name: 'LifetimeBudgetSet',
    AdSet.Field.campaign_id: <CAMPAIGN_ID>,
    AdSet.Field.lifetime_budget: 10000,
    AdSet.Field.start_time: int(time.time()),
    AdSet.Field.end_time: int(time.time() + 100000),
    AdSet.Field.optimization_goal: AdSet.OptimizationGoal.link_clicks,
    AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
    AdSet.Field.bid_amount: 500,
    AdSet.Field.promoted_object: {
        'application_id': <APP_ID>,
        'object_store_url': '<APP_STORE_URL>',
    },
    AdSet.Field.targeting: {
        'geo_locations': {
            'countries': ['US'],
        },
        'user_os': ['iOS'],
        Targeting.Field.publisher_platforms: ['facebook', 'audience_network'],
        Targeting.Field.facebook_positions: ['feed'],
    },
})

adset.remote_create(params={
    'status': AdSet.Status.paused,
})
curl \
  -F 'name=LifetimeBudgetSet' \
  -F 'lifetime_budget=100000' \
  -F 'bid_amount=500' \
  -F 'billing_event=IMPRESSIONS' \
  -F 'optimization_goal=LINK_CLICKS' \
  -F 'promoted_object={"application_id":"<APP_ID>","object_store_url":"<APP_STORE_URL>"}' \
  -F 'targeting={ 
    "facebook_positions": ["feed"], 
    "geo_locations": {"countries":["US"]}, 
    "publisher_platforms": ["facebook","audience_network"], 
    "user_os": ["IOS"] 
  }' \
  -F 'campaign_id=<CAMPAIGN_ID>' \
  -F 'end_time=2018-02-06T04:45:30+0000' \
  -F 'status=PAUSED' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/act_<AD_ACCOUNT_ID>/adsets

Etapa 4: use o criativo em um anúncio.

use FacebookAds\Object\Ad;
use FacebookAds\Object\Fields\AdFields;

$data = array(
  AdFields::NAME => 'My Ad',
  AdFields::ADSET_ID => <AD_SET_ID>,
  AdFields::CREATIVE => array(
    'creative_id' => <CREATIVE_ID>,
  ),
);

$ad = new Ad(null, 'act_<AD_ACCOUNT_ID>');
$ad->setData($data);
$ad->create(array(
  'redownload' => 1,
));
from facebookads.adobjects.ad import Ad

ad = Ad(parent_id='act_<AD_ACCOUNT_ID>')
ad[Ad.Field.name] = 'My Ad'
ad[Ad.Field.adset_id] = <AD_SET_ID>
ad[Ad.Field.creative] = {'creative_id': <CREATIVE_ID>}
ad[Ad.Field.redownload] = True
ad.remote_create(params={
    'status': Ad.Status.paused,
})
Ad ad = new AdAccount(act_<AD_ACCOUNT_ID>, context).createAd()
  .setName("My Ad")
  .setAdsetId(<AD_SET_ID>)
  .setCreative(
    new AdCreative()
      .setFieldId(<CREATIVE_ID>)
  )
  .setRedownload(true)
  .execute();
String ad_id = ad.getId();
curl \
  -F 'name=My Ad' \
  -F 'adset_id=<AD_SET_ID>' \
  -F 'creative={"creative_id":"<CREATIVE_ID>"}' \
  -F 'redownload=1' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/act_<AD_ACCOUNT_ID>/ads

Criar um anúncio de imagem de engajamento de app para celular com um link de app, otimizar para eventos do app e pagar por impressões

Etapa 1: crie a publicação da Página com a imagem. Lembre-se de que é necessário usar o PAGE_ACCESS_TOKEN e a sessão de API da Página para criar uma publicação.

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

$params = array(
  'message' => 'Check out this App today. Available on iTunes.',
  'published' => 1,
  'link' => '<APP_STORE_URL>',
  'picture' => '<IMAGE_URL>',
  'call_to_action' => array(
    'type' => 'LEARN_MORE',
    'value' => array(
      'link' => '<APP_STORE_URL>',
      'app_link' => '<APP_DEEP_LINK>',
    ),
  ),
);

$data = Api::instance()->call(
  '/'.<PAGE_ID>.'/feed',
  RequestInterface::METHOD_POST,
  $params)->getContent();
from facebookads import FacebookAdsApi

params = {
    'massage': 'Check out this App today. Available on iTunes.',
    'picture': '<IMAGE_URL>',
    'link': '<APP_STORE_URL>',
    'published': 1,
    'call_to_action': {
        'type': 'LEARN_MORE',
        'value': {
            'link': '<APP_STORE_URL>',
            'app_link': '<APP_DEEP_LINK>',
        },
    },
}

path = "/{}/feed".format(<PAGE_ID>)
data = FacebookAdsApi.get_default_api().call('POST', (path,), params=params)
curl \
  -F 'message=Check out this App today. Available on iTunes.' \
  -F 'published=1' \
  -F 'link=<APP_STORE_URL>' \
  -F 'picture=<IMAGE_URL>' \
  -F 'call_to_action={ 
    "type": "LEARN_MORE", 
    "value": {"link":"<APP_STORE_URL>","app_link":"<APP_DEEP_LINK>"} 
  }' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<PAGE_ID>/feed

Etapa 2: desenvolva o criativo do anúncio.

curl -X POST \ -F 'object_story_id="<PAGE_ID>_<POST_ID>"' \ -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 = { 'object_story_id' : '<pageID>_<postID>', }; 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( 'object_story_id' => '<pageID>_<postID>', ); 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 = { 'object_story_id': '<pageID>_<postID>', } 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() .setObjectStoryId(\"<pageID>_<postID>\") .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({ object_story_id: '<pageID>_<postID>', })

Etapa 3: defina os lances no conjunto de anúncios, otimizando para obter mais eventos do app e pagando por impressões.

Observe que também é necessário definir o promoted_object do conjunto de anúncios para incluir um custom_event_type para a otimização. Consulte os documentos sobre conjunto de anúncios para saber mais.

curl -X POST \ -F 'name="A CPA Ad Set optimized for App Events"' \ -F 'campaign_id="<AD_CAMPAIGN_ID>"' \ -F 'daily_budget=300' \ -F 'start_time="2024-05-11T08:57:45-0700"' \ -F 'end_time="2024-05-18T08:57:45-0700"' \ -F 'billing_event="IMPRESSIONS"' \ -F 'optimization_goal="OFFSITE_CONVERSIONS"' \ -F 'bid_amount=100' \ -F 'status="PAUSED"' \ -F 'promoted_object={ "application_id": "<APP_ID>", "object_store_url": "<APP_STORE_URL>", "custom_event_type": "PURCHASE" }' \ -F 'targeting={ "facebook_positions": [ "feed" ], "geo_locations": { "countries": [ "US" ] }, "user_os": [ "iOS" ] }' \ -F 'access_token=<ACCESS_TOKEN>' \ https://graph.facebook.com/v19.0/act_<AD_ACCOUNT_ID>/adsets
'use strict'; const bizSdk = require('facebook-nodejs-business-sdk'); const AdAccount = bizSdk.AdAccount; const AdSet = bizSdk.AdSet; 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' : 'A CPA Ad Set optimized for App Events', 'campaign_id' : '<adCampaignAppInstallsID>', 'daily_budget' : '300', 'start_time' : '2024-04-08T11:26:49-0700', 'end_time' : '2024-04-15T11:26:49-0700', 'billing_event' : 'IMPRESSIONS', 'optimization_goal' : 'OFFSITE_CONVERSIONS', 'bid_amount' : '100', 'status' : 'PAUSED', 'promoted_object' : {'application_id':'<appID>','object_store_url':'<appLink>','custom_event_type':'PURCHASE'}, 'targeting' : {'facebook_positions':['feed'],'geo_locations':{'countries':['US']},'user_os':['iOS']}, }; const adsets = (new AdAccount(id)).createAdSet( fields, params ); logApiCallResult('adsets api call complete.', adsets);
require __DIR__ . '/vendor/autoload.php'; use FacebookAds\Object\AdAccount; use FacebookAds\Object\AdSet; 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' => 'A CPA Ad Set optimized for App Events', 'campaign_id' => '<adCampaignAppInstallsID>', 'daily_budget' => '300', 'start_time' => '2024-04-08T11:26:49-0700', 'end_time' => '2024-04-15T11:26:49-0700', 'billing_event' => 'IMPRESSIONS', 'optimization_goal' => 'OFFSITE_CONVERSIONS', 'bid_amount' => '100', 'status' => 'PAUSED', 'promoted_object' => array('application_id' => '<appID>','object_store_url' => '<appLink>','custom_event_type' => 'PURCHASE'), 'targeting' => array('facebook_positions' => array('feed'),'geo_locations' => array('countries' => array('US')),'user_os' => array('iOS')), ); echo json_encode((new AdAccount($id))->createAdSet( $fields, $params )->exportAllData(), JSON_PRETTY_PRINT);
from facebook_business.adobjects.adaccount import AdAccount from facebook_business.adobjects.adset import AdSet 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': 'A CPA Ad Set optimized for App Events', 'campaign_id': '<adCampaignAppInstallsID>', 'daily_budget': '300', 'start_time': '2024-04-08T11:26:49-0700', 'end_time': '2024-04-15T11:26:49-0700', 'billing_event': 'IMPRESSIONS', 'optimization_goal': 'OFFSITE_CONVERSIONS', 'bid_amount': '100', 'status': 'PAUSED', 'promoted_object': {'application_id':'<appID>','object_store_url':'<appLink>','custom_event_type':'PURCHASE'}, 'targeting': {'facebook_positions':['feed'],'geo_locations':{'countries':['US']},'user_os':['iOS']}, } print AdAccount(id).create_ad_set( 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).createAdSet() .setName(\"A CPA Ad Set optimized for App Events\") .setCampaignId(\"<adCampaignAppInstallsID>\") .setDailyBudget(300L) .setStartTime(\"2024-04-08T11:26:49-0700\") .setEndTime(\"2024-04-15T11:26:49-0700\") .setBillingEvent(AdSet.EnumBillingEvent.VALUE_IMPRESSIONS) .setOptimizationGoal(AdSet.EnumOptimizationGoal.VALUE_OFFSITE_CONVERSIONS) .setBidAmount(100L) .setStatus(AdSet.EnumStatus.VALUE_PAUSED) .setPromotedObject(\"{\\"application_id\\":\\"<appID>\\",\\"object_store_url\\":\\"<appLink>\\",\\"custom_event_type\\":\\"PURCHASE\\"}\") .setTargeting( new Targeting() .setFieldFacebookPositions(Arrays.asList(\"feed\")) .setFieldGeoLocations( new TargetingGeoLocation() .setFieldCountries(Arrays.asList(\"US\")) ) .setFieldUserOs(Arrays.asList(\"iOS\")) ) .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) adsets = ad_account.adsets.create({ name: 'A CPA Ad Set optimized for App Events', campaign_id: '<adCampaignAppInstallsID>', daily_budget: '300', start_time: '2024-04-08T11:26:49-0700', end_time: '2024-04-15T11:26:49-0700', billing_event: 'IMPRESSIONS', optimization_goal: 'OFFSITE_CONVERSIONS', bid_amount: '100', status: 'PAUSED', promoted_object: {'application_id':'<appID>','object_store_url':'<appLink>','custom_event_type':'PURCHASE'}, targeting: {'facebook_positions':['feed'],'geo_locations':{'countries':['US']},'user_os':['iOS']}, })

Etapa 4: use o criativo em um anúncio.

use FacebookAds\Object\Ad;
use FacebookAds\Object\Fields\AdFields;

$data = array(
  AdFields::NAME => 'My Ad',
  AdFields::ADSET_ID => <AD_SET_ID>,
  AdFields::CREATIVE => array(
    'creative_id' => <CREATIVE_ID>,
  ),
);

$ad = new Ad(null, 'act_<AD_ACCOUNT_ID>');
$ad->setData($data);
$ad->create(array(
  'redownload' => 1,
));
from facebookads.adobjects.ad import Ad

ad = Ad(parent_id='act_<AD_ACCOUNT_ID>')
ad[Ad.Field.name] = 'My Ad'
ad[Ad.Field.adset_id] = <AD_SET_ID>
ad[Ad.Field.creative] = {'creative_id': <CREATIVE_ID>}
ad[Ad.Field.redownload] = True
ad.remote_create(params={
    'status': Ad.Status.paused,
})
Ad ad = new AdAccount(act_<AD_ACCOUNT_ID>, context).createAd()
  .setName("My Ad")
  .setAdsetId(<AD_SET_ID>)
  .setCreative(
    new AdCreative()
      .setFieldId(<CREATIVE_ID>)
  )
  .setRedownload(true)
  .execute();
String ad_id = ad.getId();
curl \
  -F 'name=My Ad' \
  -F 'adset_id=<AD_SET_ID>' \
  -F 'creative={"creative_id":"<CREATIVE_ID>"}' \
  -F 'redownload=1' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/act_<AD_ACCOUNT_ID>/ads

Exemplos de anúncios de publicação da Página

Lembre-se de que é necessário usar o PAGE_ACCESS_TOKEN e a sessão de API da Página para criar uma publicação. Para publicação de vídeo, o domínio é "video-graph.facebook.com", e não "graph.facebook.com".

Criar um anúncio de vídeo para instalação do app para celular

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;
use FacebookAds\Object\Values\AdCreativeCallToActionTypeValues;

$params = array(
  'name' => 'My Video',
  'message' => 'Check out this app!',
  'thumbnail' => '<THUMBNAIL_PATH>',
  'published' => 0,
  'call_to_action' => array(
    'type' => AdCreativeCallToActionTypeValues::INSTALL_MOBILE_APP,
    'value' => array(
      'link' => '<APP_STORE_URL>',
    ),
  ),
);

$request = Api::instance()->prepareRequest(
  '/'.<PAGE_ID>.'/videos',
  RequestInterface::METHOD_POST,
  $params);

$request->setLastLevelDomain('graph-video');
$request->getFileParams()->offsetSet('source', '<VIDEO_PATH>');
$response = Api::instance()->executeRequest($request);

$data = $response->getContent();
from facebookads import FacebookAdsApi

params = {
    'name': 'My Video',
    'massage': 'Check out this app!',
    'thumbnail': '<THUMBNAIL_URL>',
    'published': 0,
    'call_to_action': {
        'type': 'INSTALL_MOBILE_APP',
        'value': {
            'link': '<APP_STORE_URL>',
        },
    },
}

url = 'https://graph-video.facebook.com/' + FacebookAdsApi.API_VERSION
path = "/{}/videos".format(<PAGE_ID>)
files = {'source': open('<VIDEO_PATH>', 'rb')}

data = FacebookAdsApi.get_default_api().call(
    'POST',
    url + path,
    params=params,
    files=files
)
curl \
  -F 'name=My Video' \
  -F 'message=Check out this app!' \
  -F 'thumbnail=<APP_STORE_URL>' \
  -F 'published=0' \
  -F 'call_to_action={"type":"INSTALL_MOBILE_APP","value":{"link":"<APP_STORE_URL>"}}' \
  -F 'source=@<VIDEO_PATH>' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph-video.facebook.com/v2.11/<PAGE_ID>/videos

Criar um anúncio de vídeo para apps para celular com um deep link

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;
use FacebookAds\Object\Values\AdCreativeCallToActionTypeValues;

$params = array(
  'name' => 'My Video',
  'message' => 'Check out this app!',
  'thumbnail' => '<THUMBNAIL_PATH>',
  'published' => 0,
  'call_to_action' => array(
    'type' => AdCreativeCallToActionTypeValues::LEARN_MORE,
    'value' => array(
      'link' => '<APP_STORE_URL>',
      'app_link' => '<APP_DEEP_LINK>',
    ),
  ),
);
$request = Api::instance()->prepareRequest(
  '/'.<PAGE_ID>.'/videos',
  RequestInterface::METHOD_POST,
  $params);

$request->setLastLevelDomain('graph-video');
$request->getFileParams()->offsetSet('source', '<VIDEO_PATH>');
$response = Api::instance()->executeRequest($request);

$data = $response->getContent();
from facebookads import FacebookAdsApi

params = {
    'name': 'My Video',
    'massage': 'Check out this app!',
    'thumbnail': '<THUMBNAIL_URL>',
    'published': 0,
    'call_to_action': {
        'type': 'LEARN_MORE',
        'value': {
            'link': '<APP_STORE_URL>',
            'app_link': '<APP_DEEP_LINK>',
        },
    },
}

url = 'https://graph-video.facebook.com/' + FacebookAdsApi.API_VERSION
path = "/{}/videos".format(<PAGE_ID>)
files = {'source': open('<VIDEO_PATH>', 'rb')}

data = FacebookAdsApi.get_default_api().call(
    'POST',
    url + path,
    params=params,
    files=files
)
curl \
  -F 'name=My Video' \
  -F 'message=Check out this app!' \
  -F 'thumbnail=<APP_STORE_URL>' \
  -F 'published=0' \
  -F 'call_to_action={ 
    "type": "LEARN_MORE", 
    "value": {"link":"<APP_STORE_URL>","app_link":"<APP_DEEP_LINK>"} 
  }' \
  -F 'source=@<VIDEO_PATH>' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph-video.facebook.com/v2.11/<PAGE_ID>/videos

Criar um anúncio de vídeo para instalação do app para desktop

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;
use FacebookAds\Object\Values\AdCreativeCallToActionTypeValues;

$params = array(
  'name' => 'My Video',
  'message' => 'Check out this app!',
  'thumbnail' => '<THUMBNAIL_PATH>',
  'published' => 0,
  'call_to_action' => array(
    'type' => AdCreativeCallToActionTypeValues::PLAY_GAME,
    'value' => array(
      'link' => '<URL>',
    ),
  ),
);
$request = Api::instance()->prepareRequest(
  '/'.<PAGE_ID>.'/videos',
  RequestInterface::METHOD_POST,
  $params);

$request->setLastLevelDomain('graph-video');
$request->getFileParams()->offsetSet('source', '<VIDEO_PATH>');
$response = Api::instance()->executeRequest($request);

$data = $response->getContent();
from facebookads import FacebookAdsApi

params = {
    'name': 'My Video',
    'massage': 'Check out this app!',
    'thumbnail': '<THUMBNAIL_URL>',
    'published': 0,
    'call_to_action': {
        'type': 'PLAY_GAME',
        'value': {
            'link': '<URL>',
        },
    },
}

url = 'https://graph-video.facebook.com/' + FacebookAdsApi.API_VERSION
path = "/{}/videos".format(<PAGE_ID>)
files = {'source': open('<VIDEO_PATH>', 'rb')}

data = FacebookAdsApi.get_default_api().call(
    'POST',
    '<URL>' + path,
    params=params,
    files=files
)
curl \
  -F 'name=My Video' \
  -F 'message=Check out this app!' \
  -F 'thumbnail=<THUMBNAIL_PATH>' \
  -F 'published=0' \
  -F 'call_to_action={"type":"PLAY_GAME","value":{"link":"<THUMBNAIL_PATH>"}}' \
  -F 'source=@<VIDEO_PATH>' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph-video.facebook.com/v2.11/<PAGE_ID>/videos

Criar anúncios no app para desktop para anúncio de imagem de mercadorias virtuais

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;
use FacebookAds\Object\Values\AdCreativeCallToActionTypeValues;

$params = array(
  'message' => 'Buy coins now!',
  'picture' => '<IMAGE_URL>',
  'link' => '<LINK>',
  'published' => 1,
  'call_to_action' => array(
    'type' => AdCreativeCallToActionTypeValues::BUY_NOW,
    'value' => array(
      'link' => '<LINK>',
      'product_link' => '<PRODUCT_LINK>',
    ),
  ),
);

$data = Api::instance()->call(
  '/'.<PAGE_ID>.'/feed',
  RequestInterface::METHOD_POST,
  $params)->getContent();
from facebookads import FacebookAdsApi

params = {
    'massage': 'Buy coins now!',
    'picture': '<IMAGE_URL>',
    'link': '<LINK>',
    'published': 1,
    'call_to_action': {
        'type': 'BUY_NOW',
        'value': {
            'link': '<LINK>',
            'product_link': '<PRODUCT_LINK>',
        },
    },
}

data = FacebookAdsApi.get_default_api().\
    call('POST', (<PAGE_ID>, 'feed'), params=params)
curl \
  -F 'message=Buy coins now!' \
  -F 'picture=<IMAGE_URL>' \
  -F 'link=<LINK>' \
  -F 'published=1' \
  -F 'call_to_action={"type":"BUY_NOW","value":{"link":"<LINK>","product_link":"<PRODUCT_LINK>"}}' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/<PAGE_ID>/feed

Criar anúncios de app para desktop para um anúncio de vídeo de mercadorias virtuais

use FacebookAds\Api;
use FacebookAds\Http\RequestInterface;
use FacebookAds\Object\Values\AdCreativeCallToActionTypeValues;

$params = array(
  'name' => 'My Video',
  'message' => 'Buy coins now!',
  'thumbnail' => '<THUMBNAIL_PATH>',
  'published' => 0,
  'call_to_action' => array(
    'type' => AdCreativeCallToActionTypeValues::BUY_NOW,
    'value' => array(
      'link' => '<APP_URL>',
      'product_link' => '<PRODUCT_LINK>',
    ),
  ),
);

$request = Api::instance()->prepareRequest(
  '/'.<PAGE_ID>.'/videos',
  RequestInterface::METHOD_POST,
  $params);

$request->setLastLevelDomain('graph-video');
$request->getFileParams()->offsetSet('source', '<VIDEO_PATH>');
$response = Api::instance()->executeRequest($request);

$data = $response->getContent();
from facebookads import FacebookAdsApi

params = {
    'name': 'My Video',
    'massage': 'Buy coins now!',
    'thumbnail': '<THUMBNAIL_URL>',
    'published': 0,
    'call_to_action': {
        'type': 'BUY_NOW',
        'value': {
            'link': '<APP_STORE_URL>',
            'product_link': '<PRODUCT_LINK>',
        },
    },
}

files = {'source': open('<VIDEO_PATH>', 'rb')}

data = FacebookAdsApi.get_default_api().call(
    'POST', (<PAGE_ID>, 'videos'),
    params=params,
    files=files
)
curl \
  -F 'name=My Video' \
  -F 'message=Buy coins now!' \
  -F 'thumbnail=<THUMBNAIL_PATH>' \
  -F 'published=0' \
  -F 'call_to_action={ 
    "type": "BUY_NOW", 
    "value": {"link":"<THUMBNAIL_PATH>","product_link":"<THUMBNAIL_PATH>"} 
  }' \
  -F 'source=@<VIDEO_PATH>' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph-video.facebook.com/v2.11/<PAGE_ID>/videos

Anúncios de Catálogo Advantage+ para instalação de app para celular

Os Anúncios de Catálogo Advantage+ podem incentivar pessoas a instalar seu app para celular. Dessa forma, você pode redirecionar anúncios de instalação de app para celular às pessoas de acordo com o comportamento dos usuários.

Etapa 1: crie uma campanha para seu catálogo de produtos.

curl -X POST \ -F 'name="App Installs Campaign with Dynamic Product Ads"' \ -F 'objective="OUTCOME_APP_PROMOTION"' \ -F 'status="PAUSED"' \ -F 'special_ad_categories=[]' \ -F 'access_token=<ACCESS_TOKEN>' \ https://graph.facebook.com/v19.0/act_<AD_ACCOUNT_ID>/campaigns
'use strict'; const bizSdk = require('facebook-nodejs-business-sdk'); const AdAccount = bizSdk.AdAccount; const Campaign = bizSdk.Campaign; 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' : 'App Installs Campaign with Dynamic Product Ads', 'objective' : 'OUTCOME_APP_PROMOTION', 'status' : 'PAUSED', 'special_ad_categories' : [], }; const campaigns = (new AdAccount(id)).createCampaign( fields, params ); logApiCallResult('campaigns api call complete.', campaigns);
require __DIR__ . '/vendor/autoload.php'; use FacebookAds\Object\AdAccount; use FacebookAds\Object\Campaign; 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' => 'App Installs Campaign with Dynamic Product Ads', 'objective' => 'OUTCOME_APP_PROMOTION', 'status' => 'PAUSED', 'special_ad_categories' => array(), ); echo json_encode((new AdAccount($id))->createCampaign( $fields, $params )->exportAllData(), JSON_PRETTY_PRINT);
from facebook_business.adobjects.adaccount import AdAccount from facebook_business.adobjects.campaign import Campaign 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': 'App Installs Campaign with Dynamic Product Ads', 'objective': 'OUTCOME_APP_PROMOTION', 'status': 'PAUSED', 'special_ad_categories': [], } print AdAccount(id).create_campaign( 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).createCampaign() .setName(\"App Installs Campaign with Dynamic Product Ads\") .setObjective(Campaign.EnumObjective.VALUE_OUTCOME_APP_PROMOTION) .setStatus(Campaign.EnumStatus.VALUE_PAUSED) .setParam(\"special_ad_categories\", \"[]\") .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) campaigns = ad_account.campaigns.create({ name: 'App Installs Campaign with Dynamic Product Ads', objective: 'OUTCOME_APP_PROMOTION', status: 'PAUSED', special_ad_categories: [], })

Etapa 2: crie um conjunto de anúncios para um conjunto de produtos específico do catálogo de produtos acima.

use FacebookAds\Object\AdSet;
use FacebookAds\Object\Fields\AdSetFields;
use FacebookAds\Object\Fields\TargetingFields;
use FacebookAds\Object\Values\AdSetBillingEventValues;
use FacebookAds\Object\Values\AdSetOptimizationGoalValues;

$adset = new AdSet(null, 'act_<AD_ACCOUNT_ID>');

$adset->setData(array(
  AdSetFields::NAME => 'Mobile App Installs Ad Set with Dynamic Product Ads',
  AdSetFields::BID_AMOUNT => 3000,
  AdSetFields::BILLING_EVENT => AdSetBillingEventValues::IMPRESSIONS,
  AdSetFields::OPTIMIZATION_GOAL => AdSetOptimizationGoalValues::APP_INSTALLS,
  AdSetFields::DAILY_BUDGET => 15000,
  AdSetFields::CAMPAIGN_ID => <CAMPAIGN_ID>,
  AdSetFields::TARGETING => array(
    TargetingFields::GEO_LOCATIONS => array(
      'countries' => array('US'),
    ),
    TargetingFields::PUBLISHER_PLATFORMS => array(
      'facebook',
      'audience_network',
    ),
    TargetingFields::DEVICE_PLATFORMS => array('mobile'),
    TargetingFields::USER_OS => array(
      'IOS',
    ),
    TargetingFields::DYNAMIC_AUDIENCE_IDS => array(<PRODUCT_AUDIENCE_ID>),
  ),
  AdSetFields::PROMOTED_OBJECT => array(
    'product_set_id' => <PRODUCT_SET_ID>,
    'application_id' => <APP_ID>,
    'object_store_url' => '<APP_STORE_URL>',
  ),
));

$adset->create(array(
  AdSet::STATUS_PARAM_NAME => AdSet::STATUS_PAUSED,
));
from facebookads.adobjects.adset import AdSet
from facebookads.adobjects.targeting import Targeting

adset = AdSet(parent_id='act_<AD_ACCOUNT_ID>')
adset.update({
    AdSet.Field.name: 'Mobile App Installs Ad Set with Dynamic Product Ads',
    AdSet.Field.promoted_object: {
        'product_set_id': product_set_id,
        'application_id': <APP_ID>,
        'object_store_url': '<APP_STORE_URL>',
    },
    AdSet.Field.campaign_id: <CAMPAIGN_ID>,
    AdSet.Field.daily_budget: 15000,
    AdSet.Field.optimization_goal: AdSet.OptimizationGoal.app_installs,
    AdSet.Field.billing_event: AdSet.BillingEvent.impressions,
    AdSet.Field.bid_amount: 3000,
    AdSet.Field.targeting: {
        Targeting.Field.geo_locations: {
            'countries': ['US'],
        },
        Targeting.Field.publisher_platforms: ['facebook', 'audience_network'],
        Targeting.Field.device_platforms: ['mobile'],
        Targeting.Field.user_os: [
            'IOS',
        ],
        Targeting.Field.dynamic_audience_ids: [
            <PRODUCT_AUDIENCE_ID>,
        ],
    },
})

adset.remote_create(params={
    'status': AdSet.Status.paused,
})
curl \
  -F 'name=Mobile App Installs Ad Set with Dynamic Product Ads' \
  -F 'bid_amount=3000' \
  -F 'billing_event=IMPRESSIONS' \
  -F 'optimization_goal=APP_INSTALLS' \
  -F 'daily_budget=15000' \
  -F 'campaign_id=<CAMPAIGN_ID>' \
  -F 'targeting={ 
    "geo_locations": {"countries":["US"]}, 
    "publisher_platforms": ["facebook","audience_network"], 
    "device_platforms": ["mobile"], 
    "user_os": ["IOS"], 
    "dynamic_audience_ids": ["<PRODUCT_AUDIENCE_ID>"] 
  }' \
  -F 'promoted_object={ 
    "product_set_id": "<PRODUCT_SET_ID>", 
    "application_id": "<APP_ID>", 
    "object_store_url": "<APP_STORE_URL>" 
  }' \
  -F 'status=PAUSED' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.8/act_<AD_ACCOUNT_ID>/adsets

Etapa 3: desenvolva o criativo dos Anúncios de Catálogo Advantage+ usando o modelo.

curl -X POST \
  -F 'name="Advantage+ catalog ads template creative sample"' \
  -F 'object_story_spec={
       "page_id": "<PAGE_ID>",
       "template_data": {
         "call_to_action": {
           "type": "INSTALL_MOBILE_APP",
           "value": {
             "link": "http://www.example.com/appstoreurl"
           }
         },
         "message": "Test {{product.name | titleize}}",
         "link": "http://www.example.com/appstoreurl",
         "name": "Headline {{product.price}}",
         "description": "Description {{product.description}}"
       }
     }' \
  -F 'product_set_id="<PRODUCT_SET_ID>"' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v19.0/act_<AD_ACCOUNT_ID>/adcreatives

Etapa 4: use o criativo do anúncio acima em um anúncio.

use FacebookAds\Object\Ad;
use FacebookAds\Object\Fields\AdFields;

$data = array(
  AdFields::NAME => 'My Ad',
  AdFields::ADSET_ID => <AD_SET_ID>,
  AdFields::CREATIVE => array(
    'creative_id' => <CREATIVE_ID>,
  ),
);

$ad = new Ad(null, 'act_<AD_ACCOUNT_ID>');
$ad->setData($data);
$ad->create(array(
  'redownload' => 1,
));
from facebookads.adobjects.ad import Ad

ad = Ad(parent_id='act_<AD_ACCOUNT_ID>')
ad[Ad.Field.name] = 'My Ad'
ad[Ad.Field.adset_id] = <AD_SET_ID>
ad[Ad.Field.creative] = {'creative_id': <CREATIVE_ID>}
ad[Ad.Field.redownload] = True
ad.remote_create(params={
    'status': Ad.Status.paused,
})
Ad ad = new AdAccount(act_<AD_ACCOUNT_ID>, context).createAd()
  .setName("My Ad")
  .setAdsetId(<AD_SET_ID>)
  .setCreative(
    new AdCreative()
      .setFieldId(<CREATIVE_ID>)
  )
  .setRedownload(true)
  .execute();
String ad_id = ad.getId();
curl \
  -F 'name=My Ad' \
  -F 'adset_id=<AD_SET_ID>' \
  -F 'creative={"creative_id":"<CREATIVE_ID>"}' \
  -F 'redownload=1' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/v2.11/act_<AD_ACCOUNT_ID>/ads

Carregar o arquivo HTML interativo na conta de anúncios

curl \
 -X POST \
 -F "name=<name>" \
 -F "source=<>" \
 -F "access_token=<access_token>" \
 "https://graph.facebook.com/<API_VERSION>/act_<account_id>/adplayables"
  • name: nome que diferencia o ativo dos outros anúncios interativos na conta de anúncios, por exemplo, {ad_name} -> {playable_asset_name}.
  • source: caminho absoluto do arquivo na sua máquina local.
  • access_token: pode ser gerado no Explorador da Graph API.
  • Você também pode usar um número de identificação do ativo reproduzível na conta de anúncios.

Metatag em arquivo HTML reproduzível

É possível adicionar duas tags de metadados ao seu arquivo HTML 5 reproduzível. Isso permite que a Meta atribua ao seu app o elemento interativo nos anúncios.

...
<head>
  ...
  <meta name="ref-application-id" content="<YOUR_APP_ID>">
  <meta name="ref-asset-id" content="<YOUR_ASSET_ID>">
  ...
</head>
...
  • Forneça seu ID do app da Meta e a metatag do número de identificação do ativo no arquivo HTML interativo. Isso ajuda a Meta a fornecer insights precisos sobre o ativo quando ele aparecer no seu anúncio.
  • O número de identificação do ativo identifica esse elemento reproduzível no seu sistema.

Criar anúncios na conta de anúncios

  • Configure posicionamentos no Feed do Facebook. Apenas vídeo com incentivo e intersticial do Audience Network. Entre em contato com seu parceiro da Meta para obter mais informações.
  • O criativo só pode ser um vídeo com taxa de proporção >= 1.
  • Configurar o orçamento e a programação
  • Gere o criativo interativo na API:
curl \
  -F 'name=Sample Creative' \
  -F 'object_story_spec={ 
    "page_id": "<PAGE_ID>", 
    "video_data": { 
      "call_to_action": {"type":"INSTALL_MOBILE_APP","value":{"application":<APP_ID>,"link":"<APP_STORE_URL>"}}, 
      "image_url": "<THUMBNAIL_URL>", 
      "link_description": "try it out", 
      "video_id": "<VIDEO_ID>" 
    } 
  }' \
  -F 'playable_asset_id=<PLAYABLE_ASSET_ID>' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/<API_VERSION>/act_<AD_ACCOUNT_ID>/adcreatives
  • Crie o anúncio na API:
curl \
  -F 'name=My Ad' \
  -F 'status=ACTIVE' \
  -F 'adset_id=<AD_SET_ID>' \
  -F 'creative={"creative_id":"<CREATIVE_ID>"}' \
  -F 'access_token=<ACCESS_TOKEN>' \
  https://graph.facebook.com/<API_VERSION>/act_<AD_ACCOUNT_ID>/ads