Campanhas de aplicativos para dispositivos móveis

Este guia descreve como criar, configurar e monitorar o desempenho destes tipos de campanha de aplicativos para dispositivos móveis:

Campanhas universais para apps

Com uma Campanha universal para apps (UAC, na sigla em inglês), você pode promover facilmente seus aplicativos para Android e iOS nos principais Serviços do Google, incluindo a Pesquisa do Google, o Google Play, o YouTube e a Rede de Display. Este guia mostra como criar uma campanha, definir a segmentação e gerar relatórios.

Como criar uma campanha

1. Crie um orçamento

Para criar uma campanha universal para apps, primeiro adicione um orçamento. Esse tipo de campanha não é compatível com orçamentos compartilhados. Por isso, você precisa definir a propriedade isExplicitlyShared como false.

Java

// Get the BudgetService.
BudgetServiceInterface budgetService =
    adWordsServices.get(session, BudgetServiceInterface.class);

// Create the campaign budget.
Budget budget = new Budget();
budget.setName("Interplanetary Cruise App Budget #" + System.currentTimeMillis());
Money budgetAmount = new Money();
budgetAmount.setMicroAmount(50000000L);
budget.setAmount(budgetAmount);
budget.setDeliveryMethod(BudgetBudgetDeliveryMethod.STANDARD);

// Universal app campaigns don't support shared budgets.
budget.setIsExplicitlyShared(false);
BudgetOperation budgetOperation = new BudgetOperation();
budgetOperation.setOperand(budget);
budgetOperation.setOperator(Operator.ADD);

// Add the budget
Budget addedBudget = budgetService.mutate(new BudgetOperation[] {budgetOperation}).getValue(0);
    

C#

// Get the BudgetService.
using (BudgetService budgetService =
    (BudgetService) user.GetService(AdWordsService.v201802.BudgetService)) {

  // Create the campaign budget.
  Budget budget = new Budget();
  budget.name = "Interplanetary Cruise App Budget #" + ExampleUtilities.GetRandomString();
  budget.deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD;
  budget.amount = new Money();
  budget.amount.microAmount = 5000000;

  // Universal app campaigns don't support shared budgets.
  budget.isExplicitlyShared = false;

  BudgetOperation budgetOperation = new BudgetOperation();
  budgetOperation.@operator = Operator.ADD;
  budgetOperation.operand = budget;

  BudgetReturnValue budgetRetval = budgetService.mutate(
    new BudgetOperation[] { budgetOperation });
    

Python

budget_service = client.GetService('BudgetService', version='v201802')

# Create a budget.
budget = {
    'name': 'Interplanetary Cruise App Budget #%s' % uuid.uuid4(),
    'amount': {
        'microAmount': '50000000'
    },
    'deliveryMethod': 'STANDARD',
    'isExplicitlyShared': False
}

budget_operations = [{
    'operator': 'ADD',
    'operand': budget
}]

# Create the budget and return its ID.
budget_id = budget_service.mutate(budget_operations)['value'][0]['budgetId']
    

PHP

$budgetService = $adWordsServices->get($session, BudgetService::class);

// Create the shared budget (required).
$budget = new Budget();
$budget->setName('Interplanetary Cruise Budget #' . uniqid());
$money = new Money();
$money->setMicroAmount(50000000);
$budget->setAmount($money);
$budget->setDeliveryMethod(BudgetBudgetDeliveryMethod::STANDARD);

// Universal App campaigns don't support shared budgets.
$budget->setIsExplicitlyShared(false);
$operations = [];

// Create a budget operation.
$operation = new BudgetOperation();
$operation->setOperand($budget);
$operation->setOperator(Operator::ADD);
$operations[] = $operation;

// Create the budget on the server.
$result = $budgetService->mutate($operations);
$budget = $result->getValue()[0];

printf(
    "Budget with name '%s' and ID %d was created.\n",
    $budget->getName(),
    $budget->getBudgetId()
);

    

Perl

# Create the campaign budget.
my $budget = Google::Ads::AdWords::v201802::Budget->new({
  # Required attributes.
  name => "Interplanetary Cruise App Budget #" . uniqid(),
  amount =>
    Google::Ads::AdWords::v201802::Money->new({microAmount => 5000000}),
  deliveryMethod => "STANDARD",
  # Universal app campaigns don't support shared budgets.
  isExplicitlyShared => 0
});

my $budget_operation = Google::Ads::AdWords::v201802::BudgetOperation->new({
  operator => "ADD",
  operand  => $budget
});

# Add budget.
my $addedBudget =
  $client->BudgetService()->mutate({operations => ($budget_operation)})
  ->get_value();
printf
  "Budget with name '%s' and ID %d was created.\n",
  $addedBudget->get_name(), $addedBudget->get_budgetId()->get_value();
    

Ruby

# Create a budget.
budget = {
  :name => 'Interplanetary budget #%d' % (Time.new.to_f * 1000).to_i,
  :amount => {:micro_amount => 50000000},
  :delivery_method => 'STANDARD',
  # Universal app campaigns don't support shared budgets.
  :is_explicitly_shared => false
}
budget_operation = {:operator => 'ADD', :operand => budget}

# Add the budget.
return_budget = budget_srv.mutate([budget_operation])
budget_id = return_budget[:value].first[:budget_id]
    

Veja nosso guia sobre orçamentos de campanhas para mais detalhes.

2. Crie a campanha

Em seguida, crie sua campanha. Você precisa observar as seguintes restrições ao criar uma campanha universal para apps:

  1. O advertisingChannelType da campanha precisa ser definido como MULTI_CHANNEL e o advertisingChannelSubType, como UNIVERSAL_APP_CAMPAIGN.
  2. Apenas o tipo de estratégia de lances TARGET_CPA é compatível.
  3. Não é possível usar muitas das configurações de campanhas normais, como networkSetting, frequencyCap e trackingUrlTemplate, em campanhas universais para apps. Consulte os documentos de referência para ver a lista completa de configurações que não podem ser definidas.
  4. Para a v201082 e as versões mais recentes, você precisa especificar a propriedade appVendor ao criar a universalAppSetting da campanha. O valor dessa propriedade é inferido nas versões mais antigas com base na propriedade appId.

Java

// Get the CampaignService.
CampaignServiceInterface campaignService =
    adWordsServices.get(session, CampaignServiceInterface.class);

// Create the campaign.
Campaign campaign = new Campaign();
campaign.setName("Interplanetary Cruise App #" + System.currentTimeMillis());

// Recommendation: Set the campaign to PAUSED when creating it to prevent
// the ads from immediately serving. Set to ENABLED once you've added
// targeting and the ads are ready to serve.
campaign.setStatus(CampaignStatus.PAUSED);

// Set the advertising channel and subchannel types for universal app campaigns.
campaign.setAdvertisingChannelType(AdvertisingChannelType.MULTI_CHANNEL);
campaign.setAdvertisingChannelSubType(AdvertisingChannelSubType.UNIVERSAL_APP_CAMPAIGN);

// Set the campaign's bidding strategy. universal app campaigns
// only support TARGET_CPA bidding strategy.
BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();
biddingConfig.setBiddingStrategyType(BiddingStrategyType.TARGET_CPA);

// Set the target CPA to $1 / app install.
TargetCpaBiddingScheme biddingScheme = new TargetCpaBiddingScheme();
biddingScheme.setTargetCpa(new Money());
biddingScheme.getTargetCpa().setMicroAmount(1000000L);

biddingConfig.setBiddingScheme(biddingScheme);
campaign.setBiddingStrategyConfiguration(biddingConfig);

// Set the campaign's budget.
campaign.setBudget(new Budget());
campaign.getBudget().setBudgetId(createBudget(adWordsServices, session));

// Optional: Set the start date.
campaign.setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd"));

// Optional: Set the end date.
campaign.setEndDate(new DateTime().plusYears(1).toString("yyyyMMdd"));
    

C#

using (CampaignService campaignService =
    (CampaignService) user.GetService(AdWordsService.v201802.CampaignService)) {

  // Create the campaign.
  Campaign campaign = new Campaign();
  campaign.name = "Interplanetary Cruise App #" + ExampleUtilities.GetRandomString();

  // Recommendation: Set the campaign to PAUSED when creating it to prevent
  // the ads from immediately serving. Set to ENABLED once you've added
  // targeting and the ads are ready to serve.
  campaign.status = CampaignStatus.PAUSED;

  // Set the advertising channel and subchannel types for universal app campaigns.
  campaign.advertisingChannelType = AdvertisingChannelType.MULTI_CHANNEL;
  campaign.advertisingChannelSubType = AdvertisingChannelSubType.UNIVERSAL_APP_CAMPAIGN;

  // Set the campaign's bidding strategy. Universal app campaigns
  // only support TARGET_CPA bidding strategy.
  BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();
  biddingConfig.biddingStrategyType = BiddingStrategyType.TARGET_CPA;

  // Set the target CPA to $1 / app install.
  TargetCpaBiddingScheme biddingScheme = new TargetCpaBiddingScheme();
  biddingScheme.targetCpa = new Money();
  biddingScheme.targetCpa.microAmount = 1000000;

  biddingConfig.biddingScheme = biddingScheme;
  campaign.biddingStrategyConfiguration = biddingConfig;

  // Set the campaign's budget.
  campaign.budget = new Budget();
  campaign.budget.budgetId = CreateBudget(user).budgetId;

  // Optional: Set the start date.
  campaign.startDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd");

  // Optional: Set the end date.
  campaign.endDate = DateTime.Now.AddYears(1).ToString("yyyyMMdd");
    

Python

# Initialize appropriate services.
campaign_service = client.GetService('CampaignService', version='v201802')

budget_id = CreateBudget(client)

# Create the Universal App campaign.
universal_app_campaign = {
    'name': 'Interplanetary Cruise App #%s' % uuid.uuid4(),
    # Recommendation: Set the campaign to PAUSED when creating it to stop the
    # ads from immediately serving. Set to ENABLED once you've added targeting
    # and the ads are ready to serve.
    'status': 'PAUSED',
    'advertisingChannelType': 'MULTI_CHANNEL',
    'advertisingChannelSubType': 'UNIVERSAL_APP_CAMPAIGN',
    # Set the campaign's bidding strategy. Universal app campaigns only
    # support TARGET_CPA bidding strategy.
    'biddingStrategyConfiguration': {
        # Set the target CPA to $1 / app install.
        'biddingScheme': {
            'xsi_type': 'TargetCpaBiddingScheme',
            'targetCpa': {
                'microAmount': '1000000'
            }
        },
        'biddingStrategyType': 'TARGET_CPA'
    },
    # Note that only the budgetId is required
    'budget': {
        'budgetId': budget_id
    },
    # Optional fields
    'startDate': (datetime.datetime.now() +
                  datetime.timedelta(1)).strftime('%Y%m%d'),
    'endDate': (datetime.datetime.now() +
                datetime.timedelta(365)).strftime('%Y%m%d'),
}
    

PHP

$campaignService = $adWordsServices->get($session, CampaignService::class);

// Create campaign with some properties set.
$campaign = new Campaign();
$campaign->setName('Interplanetary Cruise #' . uniqid());
// Recommendation: Set the campaign to PAUSED when creating it to stop
// the ads from immediately serving. Set to ENABLED once you've added
// targeting and the ads are ready to serve.
$campaign->setStatus(CampaignStatus::PAUSED);

// Set the advertising channel and subchannel types for Universal app
// campaigns.
$campaign->setAdvertisingChannelType(AdvertisingChannelType::MULTI_CHANNEL);
$campaign->setAdvertisingChannelSubType(
    AdvertisingChannelSubType::UNIVERSAL_APP_CAMPAIGN
);

// Set the campaign's bidding strategy. Universal App campaigns
// only support TARGET_CPA bidding strategy.
$biddingStrategyConfiguration = new BiddingStrategyConfiguration();
$biddingStrategyConfiguration->setBiddingStrategyType(
    BiddingStrategyType::TARGET_CPA
);

// Set the target CPA to $1 / app install.
$biddingScheme = new TargetCpaBiddingScheme();
$money = new Money();
$money->setMicroAmount(1000000);
$biddingScheme->setTargetCpa($money);

$biddingStrategyConfiguration->setBiddingScheme($biddingScheme);
$campaign->setBiddingStrategyConfiguration($biddingStrategyConfiguration);

// Set shared budget (required).
$campaign->setBudget(new Budget());
$campaign->getBudget()->setBudgetId(
    self::createBudget($adWordsServices, $session)
);

// Optional: Set the start date.
$campaign->setStartDate(date('Ymd', strtotime('+1 day')));

// Optional: Set the end date.
$campaign->setEndDate(date('Ymd', strtotime('+1 year')));
    

Perl

my (undef, undef, undef, $mday, $mon, $year) = localtime(time + 60 * 60 * 24);
my $start_date = sprintf("%d%02d%02d", ($year + 1900), ($mon + 1), $mday);
(undef, undef, undef, $mday, $mon, $year) =
  localtime(time + 60 * 60 * 24 * 365);
my $end_date = sprintf("%d%02d%02d", ($year + 1900), ($mon + 1), $mday);

my $budgetId = create_budget($client);

my $campaign = Google::Ads::AdWords::v201802::Campaign->new({
    name => "Interplanetary Cruise App #" . uniqid(),
    # Bidding strategy (required).
    # Set the campaign's bidding strategy. Universal app campaigns
    # only support TARGET_CPA bidding strategy.
    biddingStrategyConfiguration =>
      Google::Ads::AdWords::v201802::BiddingStrategyConfiguration->new({
        biddingStrategyType => "TARGET_CPA",
        # Set the target CPA to $1 / app install.
        biddingScheme =>
          Google::Ads::AdWords::v201802::TargetCpaBiddingScheme->new({
            targetCpa => Google::Ads::AdWords::v201802::Money->new(
              {microAmount => 1000000})})}
      ),
    # Budget (required) - note only the budgetId is required.
    budget =>
      Google::Ads::AdWords::v201802::Budget->new({budgetId => $budgetId}),
    # Advertising channel type (required).
    # Set the advertising channel and subchannel types for universal
    # app campaigns.
    advertisingChannelType    => "MULTI_CHANNEL",
    advertisingChannelSubType => "UNIVERSAL_APP_CAMPAIGN",
    settings                  => [$universalAppSetting, $geoSetting],
    # Additional properties (non-required).
    startDate => $start_date,
    endDate   => $end_date,
    # Recommendation: Set the campaign to PAUSED when creating it to stop
    # the ads from immediately serving. Set to ENABLED once you've added
    # targeting and the ads are ready to serve.
    status    => "PAUSED"
  });
    

Ruby

campaign_srv = adwords.service(:CampaignService, API_VERSION)
budget_srv = adwords.service(:BudgetService, API_VERSION)

# Create a budget.
budget = {
  :name => 'Interplanetary budget #%d' % (Time.new.to_f * 1000).to_i,
  :amount => {:micro_amount => 50000000},
  :delivery_method => 'STANDARD',
  # Universal app campaigns don't support shared budgets.
  :is_explicitly_shared => false
}
budget_operation = {:operator => 'ADD', :operand => budget}

# Add the budget.
return_budget = budget_srv.mutate([budget_operation])
budget_id = return_budget[:value].first[:budget_id]

# Create campaigns.
universal_app_campaign = {
  :name => "Interplanetary Cruise #%d" % (Time.new.to_f * 1000).to_i,
  # Recommendation: Set the campaign to PAUSED when creating it to stop the
  # ads from immediately serving. Set it to ENABLED once you've added
  # targeting and the ads are ready to serve.
  :status => 'PAUSED',
  # Set the advertising channel and subchannel types for universal app
  # campaigns.
  :advertising_channel_type => 'MULTI_CHANNEL',
  :advertising_channel_sub_type => 'UNIVERSAL_APP_CAMPAIGN',
  # Set the campaign's bidding strategy. Universal app campaigns only support
  # the TARGET_CPA bidding strategy.
  :bidding_strategy_configuration => {
    :bidding_scheme => {
      :xsi_type => 'TargetCpaBiddingScheme',
      :target_cpa => {
        :micro_amount => 1000000
      }
    }
  },
  # Budget (required) - note only the budget ID is required.
  :budget => {:budget_id => budget_id},
  # Optional fields:
  :start_date =>
      DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d'),
  :end_date =>
      DateTime.parse((Date.today + 365).to_s).strftime('%Y%m%d')
}
    

3. Personalize seus anúncios

Diferentemente dos outros tipos de campanha, as campanhas universais para apps não permitem que os usuários criem anúncios. Os anúncios são gerados em vários formatos e redes com base na sua ficha da loja de aplicativos, em ideias de texto adicionais e nos recursos que você especificou nas configurações da campanha. O snippet a seguir mostra como definir os recursos da sua campanha.

Java

// Set the campaign's assets and ad text ideas. These values will be used to
// generate ads.
UniversalAppCampaignSetting universalAppSetting = new UniversalAppCampaignSetting();
universalAppSetting.setAppId("com.labpixies.colordrips");
universalAppSetting.setAppVendor(MobileApplicationVendor.VENDOR_GOOGLE_MARKET);
universalAppSetting.setDescription1("A cool puzzle game");
universalAppSetting.setDescription2("Remove connected blocks");
universalAppSetting.setDescription3("3 difficulty levels");
universalAppSetting.setDescription4("4 colorful fun skins");

// Optional: You can set up to 20 image assets for your campaign.
// See UploadImage.java for an example on how to upload images.
//
// universalAppSetting.setImageMediaIds(new long[] { INSERT_IMAGE_MEDIA_ID_HERE });
    

C#

// Set the campaign's assets and ad text ideas. These values will be used to
// generate ads.
UniversalAppCampaignSetting universalAppSetting = new UniversalAppCampaignSetting();
universalAppSetting.appId = "com.labpixies.colordrips";
universalAppSetting.appVendor = MobileApplicationVendor.VENDOR_GOOGLE_MARKET;
universalAppSetting.description1 = "A cool puzzle game";
universalAppSetting.description2 = "Remove connected blocks";
universalAppSetting.description3 = "3 difficulty levels";
universalAppSetting.description4 = "4 colorful fun skins";

// Optional: You can set up to 20 image assets for your campaign.
// See UploadImage.cs for an example on how to upload images.
//
// universalAppSetting.imageMediaIds = new long[] { INSERT_IMAGE_MEDIA_ID_HERE };
    

Python

universal_app_campaign['settings'] = [
    # Set the campaign's assets and ad text ideas. These values will
    # be used to generate ads.
    {
        'xsi_type': 'UniversalAppCampaignSetting',
        'appId': 'com.labpixies.colordrips',
        'appVendor': 'VENDOR_GOOGLE_MARKET',
        'description1': 'A cool puzzle game',
        'description2': 'Remove connected blocks',
        'description3': '3 difficulty levels',
        'description4': '4 colorful fun skins',
        # Optional: You can set up to 20 image assets for your campaign.
        # See upload_image.py for an example on how to upload images.
        #
        # 'imageMediaIds': [INSERT_IMAGE_MEDIA_ID(s)_HERE]
    }
]
    

PHP

// Set the campaign's assets and ad text ideas. These values will be used to
// generate ads.
$universalAppSetting = new UniversalAppCampaignSetting();
$universalAppSetting->setAppId('com.labpixies.colordrips');
$universalAppSetting->setAppVendor(
    MobileApplicationVendor::VENDOR_GOOGLE_MARKET
);
$universalAppSetting->setDescription1('A cool puzzle game');
$universalAppSetting->setDescription2('Remove connected blocks');
$universalAppSetting->setDescription3('3 difficulty levels');
$universalAppSetting->setDescription4('4 colorful fun skins');

// Optional: You can set up to 20 image assets for your campaign.
// See UploadImage.php for an example on how to upload images.
//
// $universalAppSetting->imageMediaIds = [INSERT_IMAGE_MEDIA_ID_HERE];
    

Perl

# Set the campaign's assets and ad text ideas. These values will be used to
# generate ads.
my $universalAppSetting =
  Google::Ads::AdWords::v201802::UniversalAppCampaignSetting->new({
    appId        => "com.labpixies.colordrips",
    appVendor    => "VENDOR_GOOGLE_MARKET",
    description1 => "A cool puzzle game",
    description2 => "Remove connected blocks",
    description3 => "3 difficulty levels",
    description4 => "4 colorful fun skins"
  });

# Optional: You can set up to 20 image assets for your campaign.
# See upload_image.pl for an example on how to upload images.
# universalAppSetting->set_imageMediaIds([INSERT_IMAGE_MEDIA_ID_HERE]);
    

Ruby

universal_app_setting = {
  # Set the campaign's assets and ad text ideas. These values will be used to
  # generate ads.
  :xsi_type => 'UniversalAppCampaignSetting',
  :app_id => 'com.labpixies.colordrips',
  :app_vendor => 'VENDOR_GOOGLE_MARKET',
  :description1 => 'A cool puzzle game',
  :description2 => 'Remove connected blocks',
  :description3 => '3 difficulty levels',
  :description4 => '4 colorful fun skins'
  # Optional: You can set up to 20 image assets for your campaign. See
  # upload_image.rb for an example on how to upload images.
  #
  # :image_media_ids => [INSERT_IMGAGE_MEDIA_ID(s)_HERE]
}
    

4. Otimize sua campanha

Você pode otimizar sua campanha usando duas configurações:

  • universalAppBiddingStrategyGoalType permite que você especifique um tipo de meta ao otimizar a estratégia de lances da campanha.

  • Quando você seleciona OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME como o tipo de meta da estratégia de lances, também é possível otimizar para um conjunto de tipos de conversão no aplicativo usando o campo selectiveOptimization da campanha. Você pode usar ConversionTrackerService para recuperar a lista de todos os rastreadores de conversão.

Java

// Optimize this campaign for getting new users for your app.
universalAppSetting.setUniversalAppBiddingStrategyGoalType(
    UniversalAppBiddingStrategyGoalType.OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME);

// If you select the OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal type, then also specify
// your in-app conversion types so AdWords can focus your campaign on people who are
// most likely to complete the corresponding in-app actions.
// Conversion type IDs can be retrieved using ConversionTrackerService.get.
//
// campaign.selectiveOptimization = new SelectiveOptimization();
// campaign.selectiveOptimization.conversionTypeIds =
//    new long[] { INSERT_CONVERSION_TYPE_ID_1_HERE, INSERT_CONVERSION_TYPE_ID_2_HERE };

// Optional: Set the campaign settings for Advanced location options.
GeoTargetTypeSetting geoSetting = new GeoTargetTypeSetting();
geoSetting.setPositiveGeoTargetType(
    GeoTargetTypeSettingPositiveGeoTargetType.LOCATION_OF_PRESENCE);
geoSetting.setNegativeGeoTargetType(GeoTargetTypeSettingNegativeGeoTargetType.DONT_CARE);

campaign.setSettings(new Setting[] {universalAppSetting, geoSetting});
    

C#

// Optimize this campaign for getting new users for your app.
universalAppSetting.universalAppBiddingStrategyGoalType =
    UniversalAppBiddingStrategyGoalType.OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME;

// Optional: If you select the OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal
// type, then also specify your in-app conversion types so AdWords can
// focus your campaign on people who are most likely to complete the
// corresponding in-app actions.
// Conversion type IDs can be retrieved using ConversionTrackerService.get.
//
// campaign.selectiveOptimization = new SelectiveOptimization();
// campaign.selectiveOptimization.conversionTypeIds =
//    new long[] { INSERT_CONVERSION_TYPE_ID_1_HERE, INSERT_CONVERSION_TYPE_ID_2_HERE };

// Optional: Set the campaign settings for Advanced location options.
GeoTargetTypeSetting geoSetting = new GeoTargetTypeSetting();
geoSetting.positiveGeoTargetType =
    GeoTargetTypeSettingPositiveGeoTargetType.LOCATION_OF_PRESENCE;
geoSetting.negativeGeoTargetType =
    GeoTargetTypeSettingNegativeGeoTargetType.DONT_CARE;

campaign.settings = new Setting[] { universalAppSetting, geoSetting };
    

Python

# Optimize this campaign for getting new users for your app.
universal_app_campaign_setting = universal_app_campaign['settings'][0]
universal_app_campaign_setting['universalAppBiddingStrategyGoalType'] = (
    'OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME')

# Optional: If you select the OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal type,
# then also specify your in-app conversion types so AdWords can focus your
# campaign on people who are most likely to complete the corresponding in-app
# actions.
#
# Conversions type IDs can be retrieved using ConversionTrackerService.get.
# universal_app_campaign['selectiveOptimization'] = {
#     'conversionTypeIds': [INSERT_CONVERSION_TYPE_ID(s)_HERE]
# }

# Optional: Set the campaign settings for Advanced location options.
universal_app_campaign['settings'].append({
    'xsi_type': 'GeoTargetTypeSetting',
    'positiveGeoTargetType': 'DONT_CARE',
    'negativeGeoTargetType': 'DONT_CARE'
})
    

PHP

// Optimize this campaign for getting new users for your app.
$universalAppSetting->setUniversalAppBiddingStrategyGoalType(
    UniversalAppBiddingStrategyGoalType
    ::OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME
);

// If you select bidding strategy goal type as
// OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME, then you may specify a set of
// conversion types for in-app actions to optimize the campaign towards.
// Conversion type IDs can be retrieved using ConversionTrackerService.get.
//
// $campaign->selectiveOptimization = new SelectiveOptimization();
// $campaign->selectiveOptimization->conversionTypeIds = [
//     INSERT_CONVERSION_TYPE_ID_1_HERE,
//     INSERT_CONVERSION_TYPE_ID_2_HERE
// ];

// Optional: Set the campaign settings for Advanced location options.
$geoTargetTypeSetting = new GeoTargetTypeSetting();
$geoTargetTypeSetting->setNegativeGeoTargetType(
    GeoTargetTypeSettingNegativeGeoTargetType::LOCATION_OF_PRESENCE
);
$campaign->setSettings([$universalAppSetting, $geoTargetTypeSetting]);
    

Perl

# Optimize this campaign for getting new users for your app.
$universalAppSetting->set_universalAppBiddingStrategyGoalType(
  "OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME");

# If you select the OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal type, then also
# specify your in-app conversion types so AdWords can focus your campaign on
# people who are most likely to complete the corresponding in-app actions.
# Conversion type IDs can be retrieved using ConversionTrackerService.get.

# my $selectiveOptimization =
# Google::Ads::AdWords::v201802::SelectiveOptimization->new({
#  conversionTypeIds =>
#    [INSERT_CONVERSION_TYPE_ID_1_HERE, INSERT_CONVERSION_TYPE_ID_2_HERE]
# });
# $campaign->set_selectiveOptimization($selectiveOptimization);

# Optional: Set the campaign settings for advanced location options.
my $geoSetting = Google::Ads::AdWords::v201802::GeoTargetTypeSetting->new({
  positiveGeoTargetType => "LOCATION_OF_PRESENCE",
  negativeGeoTargetType => "DONT_CARE"
});
    

Ruby

# Optimize this campaign for getting new users for your app.
universal_app_setting[:universal_app_bidding_strategy_goal_type] =
    'OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME'

# Optional: If you select OPTIMIZE_FOR_IN_APP_CONVERSION_VOLUME goal type,
# then also specify your in-app conversion types so AdWords can focus your
# campaign on people who are most likely to complete the corresponding in-app
# actions.
# Conversion type IDs can be retrieved using ConversionTrackerService.get.
#
# universal_app_campaign[:selective_optimization] = {
#   :conversion_type_ids => [INSERT_CONVERSION_TYPE_ID(s)_HERE]
# }

# Optional: Set the campaign settings for Advanced location options.
geo_setting = {
  :xsi_type => 'GeoTargetTypeSetting',
  :positive_geo_target_type => 'DONT_CARE',
  :negative_geo_target_type => 'DONT_CARE'
}

universal_app_campaign[:settings] = [
  universal_app_setting,
  geo_setting
]
    

Por fim, crie sua campanha usando o método CampaignService.mutate:

Java

// Create the operation.
CampaignOperation operation = new CampaignOperation();
operation.setOperand(campaign);
operation.setOperator(Operator.ADD);

CampaignOperation[] operations = new CampaignOperation[] {operation};

// Add the campaign.
CampaignReturnValue result = campaignService.mutate(operations);

// Display the results.
for (Campaign newCampaign : result.getValue()) {
  System.out.printf(
      "Universal app campaign with name '%s' and ID %d was added.%n",
      newCampaign.getName(), newCampaign.getId());

  // Optional: Set the campaign's location and language targeting. No other targeting
  // criteria can be used for universal app campaigns.
  setCampaignTargetingCriteria(newCampaign, adWordsServices, session);
}
    

C#

  // Create the operation.
  CampaignOperation operation = new CampaignOperation();
  operation.@operator = Operator.ADD;
  operation.operand = campaign;

  try {
    // Add the campaign.
    CampaignReturnValue retVal = campaignService.mutate(
        new CampaignOperation[] { operation });

    // Display the results.
    if (retVal != null && retVal.value != null && retVal.value.Length > 0) {
      foreach (Campaign newCampaign in retVal.value) {
        Console.WriteLine("Universal app campaign with name = '{0}' and id = '{1}' " +
            "was added.", newCampaign.name, newCampaign.id);

        // Optional: Set the campaign's location and language targeting. No other targeting
        // criteria can be used for universal app campaigns.
        SetCampaignTargetingCriteria(user, newCampaign);
      }
    } else {
      Console.WriteLine("No universal app campaigns were added.");
    }
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to add universal app campaigns.", e);
  }
}
    

Python

# Construct operations and add campaigns.
operations = [{
    'operator': 'ADD',
    'operand': universal_app_campaign
}]

campaigns = campaign_service.mutate(operations)['value']
    

PHP

// Create a campaign operation and add it to the operations list.
$operations = [];
$operation = new CampaignOperation();
$operation->setOperand($campaign);
$operation->setOperator(Operator::ADD);
$operations[] = $operation;

// Create the campaign on the server and print out some information for the
// campaign.
$result = $campaignService->mutate($operations);
foreach ($result->getValue() as $campaign) {
    printf(
        "Universal App Campaign with name '%s' and ID %d was added.\n",
        $campaign->getName(),
        $campaign->getId()
    );
    // Optional: Set the campaign's location and language targeting. No other
    // targeting criteria can be used for Universal App campaigns.
    self::setCampaignTargetingCriteria(
        $campaign->getId(),
        $adWordsServices,
        $session
    );
}
    

Perl

# Create operation.
my $campaign_operation =
  Google::Ads::AdWords::v201802::CampaignOperation->new({
    operator => "ADD",
    operand  => $campaign
  });

# Add campaigns.
my $result =
  $client->CampaignService()->mutate({operations => [$campaign_operation]});

# Display campaigns.
foreach my $new_campaign (@{$result->get_value()}) {
  printf "Universal app campaign with name \"%s\" and ID %s was added.\n",
    $new_campaign->get_name(), $new_campaign->get_id();
  # Optional: Set the campaign's location and language targeting. No other
  # targeting criteria can be used for universal app campaigns.
  set_campaign_targeting_criteria($client, $new_campaign->get_id());
}
    

Ruby

  # Construct the operation and add the campaign.
  operations = [{
    :operator => 'ADD',
    :operand => universal_app_campaign
  }]

  campaigns = campaign_srv.mutate(operations)[:value]

  if campaigns
    campaigns.each do |campaign|
      puts "Universal app campaign with name '%s' and ID %d was added." %
          [campaign[:name], campaign[:id]]
      set_campaign_targeting_criteria(adwords, campaign)
    end
  else
    raise new StandardError, 'No universal app campaigns were added.'
  end
end

def set_campaign_targeting_criteria(adwords, campaign)
  campaign_criterion_service =
      adwords.service(:CampaignCriterionService, API_VERSION)

  criteria = [
    {
      :xsi_type => 'Location',
      :id => 21137 # California
    },
    {
      :xsi_type => 'Location',
      :id => 2484 # Mexico
    },
    {
      :xsi_type => 'Language',
      :id => 1000 # English
    },
    {
      :xsi_type => 'Language',
      :id => 1003 # Spanish
    }
  ]

  operations = criteria.map do |criterion|
    {
      :operator => 'ADD',
      :operand => {
        :campaign_id => campaign[:id],
        :criterion => criterion
      }
    }
  end

  response = campaign_criterion_service.mutate(operations)

  if response and response[:value]
    # Display the added campaign targets.
    response[:value].each do |criterion|
      puts 'Campaign criteria of type "%s" and id %d was added.' % [
          criterion[:criterion][:criterion_type],
          criterion[:criterion][:id]
      ]
    end
  end
end

if __FILE__ == $0
  API_VERSION = :v201802

  begin
    add_universal_app_campaigns()

  # Authorization error.
  rescue AdsCommon::Errors::OAuth2VerificationRequired => e
    puts "Authorization credentials are not valid. Edit adwords_api.yml for " +
        "OAuth2 client ID and secret and run misc/setup_oauth2.rb example " +
        "to retrieve and store OAuth2 tokens."
    puts "See this wiki page for more details:\n\n  " +
        'https://github.com/googleads/google-api-ads-ruby/wiki/OAuth2'

  # HTTP errors.
  rescue AdsCommon::Errors::HttpError => e
    puts "HTTP Error: %s" % e

  # API errors.
  rescue AdwordsApi::Errors::ApiException => e
    puts "Message: %s" % e.message
    puts 'Errors:'
    e.errors.each_with_index do |error, index|
      puts "\tError [%d]:" % (index + 1)
      error.each do |field, value|
        puts "\t\t%s: %s" % [field, value]
      end
    end
  end
end

    

Como fazer o upload de mídias

É possível especificar até 20 recursos de imagens em campanhas universais para apps. Esses recursos serão utilizados pelo Google AdWords para criar os anúncios. Você pode utilizar o método MediaService.upload para fazer o upload de imagens.

Java

MediaServiceInterface mediaService =
    adWordsServices.get(session, MediaServiceInterface.class);

// Create image.
Image image = new Image();
image.setData(
    com.google.api.ads.common.lib.utils.Media.getMediaDataFromUrl("https://goo.gl/3b9Wfh"));
image.setType(MediaMediaType.IMAGE);

Media[] media = new Media[] {image};

// Upload image.
Media[] result = mediaService.upload(media);
    

C#

using (MediaService mediaService = (MediaService) user.GetService(
    AdWordsService.v201802.MediaService)) {

  // Create the image.
  Image image = new Image();
  image.data = MediaUtilities.GetAssetDataFromUrl("https://goo.gl/3b9Wfh");
  image.type = MediaMediaType.IMAGE;

  try {
    // Upload the image.
    Media[] result = mediaService.upload(new Media[] { image });
    

Python

media_service = client.GetService('MediaService', version='v201802')

with open(image_filename, 'rb') as image_handle:
  image_data = image_handle.read().decode('utf-8')

# Construct media and upload image.
media = [{
    'xsi_type': 'Image',
    'data': image_data,
    'type': 'IMAGE'
}]
media = media_service.upload(media)[0]
    

PHP

$mediaService = $adWordsServices->get($session, MediaService::class);

// Create an image and add it to the images list.
$image = new Image();
$image->setData(file_get_contents('http://goo.gl/HJM3L'));
$image->setType(MediaMediaType::IMAGE);
$images = [$image];

// Upload the image to the server.
$result = $mediaService->upload($images);
    

Perl

# Create image.
my $image_data = Google::Ads::Common::MediaUtils::get_base64_data_from_url(
  "https://goo.gl/3b9Wfh");
my $image = Google::Ads::AdWords::v201802::Image->new({
    data => $image_data,
    type => "IMAGE"
  }
);

# Upload image.
$image = $client->MediaService()->upload({media => [$image]});
    

Ruby

media_srv = adwords.service(:MediaService, API_VERSION)

# This utility method retrieves the contents of a URL using all of the config
# options provided to the Api object.
image_url = 'https://goo.gl/3b9Wfh'
image_data = AdsCommon::Http.get(image_url, adwords.config)
base64_image_data = Base64.encode64(image_data)

# Create image.
image = {
  # The 'xsi_type' field allows you to specify the xsi:type of the object
  # being created. It's only necessary when you must provide an explicit
  # type that the client library can't infer.
  :xsi_type => 'Image',
  :data => base64_image_data,
  :type => 'IMAGE'
}

# Upload image.
response = media_srv.upload([image])
    

Como usar "ListOperations"

As campanhas universais para apps usam ListOperations para definir os campos de lista, como imageMediaIds. ListOperations descreve o comportamento dos elementos em uma lista e sempre será definido em um objeto da API (por exemplo imageMediaIdsOps descreve como atualizar os imageMediaIds). O número de operadores em ListOperations precisa ser igual ao número de elementos da lista correspondente. Cada operador, juntamente com seu elemento da lista correspondente, descreve uma alteração pretendida.

Suponha que imageMediaIds continha os valores iniciais [1000, 1001, 1002]. A tabela abaixo mostra uma chamada mutate para atualizar imageMediaIds usando ListOperations.

Índice do item Código da mídia de imagem ListOperation Significado
0 1003 PUT O código do item "1003" está sendo adicionado, já que estava ausente da lista original.
1 1002 REMOVE O código do item "1002" está sendo removido.

imageMediaIds terá os valores [1000, 1001, 1003] depois de uma chamada "mutate".

Segmentação

As campanhas universais para apps são compatíveis com apenas duas formas de segmentação: critérios de idioma e de local no nível da campanha. Por padrão, a campanha segmenta todos os locais e idiomas. O snippet de código a seguir segmenta a campanha para Califórnia e México, nos idiomas inglês e espanhol.

Java

// Get the CampaignCriterionService.
CampaignCriterionServiceInterface campaignCriterionService =
    adWordsServices.get(session, CampaignCriterionServiceInterface.class);

// Create locations. The IDs can be found in the documentation or
// retrieved with the LocationCriterionService.
Location california = new Location();
california.setId(21137L);

Location mexico = new Location();
mexico.setId(2484L);

// Create languages. The IDs can be found in the documentation or
// retrieved with the ConstantDataService.
Language english = new Language();
english.setId(1000L);

Language spanish = new Language();
spanish.setId(1003L);

List<Criterion> criteria = new ArrayList<>(Arrays.asList(california, mexico, english, spanish));

// Create operations to add each of the criteria above.
List<CampaignCriterionOperation> operations = new ArrayList<>();
for (Criterion criterion : criteria) {
  CampaignCriterionOperation operation = new CampaignCriterionOperation();

  CampaignCriterion campaignCriterion = new CampaignCriterion();
  campaignCriterion.setCampaignId(campaign.getId());
  campaignCriterion.setCriterion(criterion);
  operation.setOperand(campaignCriterion);

  operation.setOperator(Operator.ADD);

  operations.add(operation);
}

// Set the campaign targets.
CampaignCriterionReturnValue returnValue =
    campaignCriterionService.mutate(
        operations.toArray(new CampaignCriterionOperation[operations.size()]));

if (returnValue != null && returnValue.getValue() != null) {
  // Display added campaign targets.
  for (CampaignCriterion campaignCriterion : returnValue.getValue()) {
    System.out.printf(
        "Campaign criteria of type '%s' and ID %d was added.%n",
        campaignCriterion.getCriterion().getCriterionType(),
        campaignCriterion.getCriterion().getId());
  }
}
    

C#

using (CampaignCriterionService campaignCriterionService =
    (CampaignCriterionService) user.GetService(
        AdWordsService.v201802.CampaignCriterionService)) {

  // Create locations. The IDs can be found in the documentation or
  // retrieved with the LocationCriterionService.
  Location california = new Location() {
    id = 21137L
  };

  Location mexico = new Location() {
    id = 2484L
  };

  // Create languages. The IDs can be found in the documentation or
  // retrieved with the ConstantDataService.
  Language english = new Language() {
    id = 1000L
  };

  Language spanish = new Language() {
    id = 1003L
  };

  List<Criterion> criteria = new List<Criterion>() {
  california, mexico, english, spanish };

  // Create operations to add each of the criteria above.
  List<CampaignCriterionOperation> operations = new List<CampaignCriterionOperation>();
  foreach (Criterion criterion in criteria) {
    CampaignCriterionOperation operation = new CampaignCriterionOperation() {
      operand = new CampaignCriterion() {
        campaignId = campaign.id,
        criterion = criterion
      },
      @operator = Operator.ADD
    };

    operations.Add(operation);
  }

  // Set the campaign targets.
  CampaignCriterionReturnValue retVal = campaignCriterionService.mutate(
      operations.ToArray());

  if (retVal != null && retVal.value != null) {
    // Display the added campaign targets.
    foreach (CampaignCriterion criterion in retVal.value) {
      Console.WriteLine("Campaign criteria of type '{0}' and id '{1}' was added.",
                        criterion.criterion.CriterionType, criterion.criterion.id);
    }
  }
}
    

Python

campaign_criterion_service = client.GetService('CampaignCriterionService')

# Create locations. The IDs can be found in the documentation or retrieved
# with the LocationCriterionService.
criteria = [
    {
        'xsi_type': 'Location',
        'id': 21137  # California
    },
    {
        'xsi_type': 'Location',
        'id': 2484  # Mexico
    },
    {
        'xsi_type': 'Language',
        'id': 1000  # English
    },
    {
        'xsi_type': 'Language',
        'id': 1003  # Spanish
    }
]

operations = [{
    'operator': 'ADD',
    'operand': {
        'campaignId': campaign['id'],
        'criterion': criterion
    }
} for criterion in criteria]

response = campaign_criterion_service.mutate(operations)

if response and 'value' in response:
  # Display the added campaign targets.
  for criterion in response['value']:
    print ('Campaign criteria of type "%s" and id "%s" was added.'
           % (criterion['criterion']['type'],
              criterion['criterion']['id']))
    

PHP

$campaignCriterionService = $adWordsServices->get($session, CampaignCriterionService::class);

$campaignCriteria = [];
// Create locations. The IDs can be found in the documentation or retrieved
// with the LocationCriterionService.
$california = new Location();
$california->setId(21137);
$campaignCriteria[] = new CampaignCriterion($campaignId, null, $california);

$mexico = new Location();
$mexico->setId(2484);
$campaignCriteria[] = new CampaignCriterion($campaignId, null, $mexico);

// Create languages. The IDs can be found in the documentation or retrieved
// with the ConstantDataService.
$english = new Language();
$english->setId(1000);
$campaignCriteria[] = new CampaignCriterion($campaignId, null, $english);

$spanish = new Language();
$spanish->setId(1003);
$campaignCriteria[] = new CampaignCriterion($campaignId, null, $spanish);

// Create operations to add each of the criteria above.
$operations = [];
foreach ($campaignCriteria as $campaignCriterion) {
    $operation = new CampaignCriterionOperation();
    $operation->setOperand($campaignCriterion);
    $operation->setOperator(Operator::ADD);
    $operations[] = $operation;
}

// Set the campaign targets.
$result = $campaignCriterionService->mutate($operations);

// Display added campaign targets.
foreach ($result->getValue() as $campaignCriterion) {
    printf(
        "Campaign criterion of type '%s' and ID %d was added.\n",
        $campaignCriterion->getCriterion()->getType(),
        $campaignCriterion->getCriterion()->getId()
    );
}
    

Perl

# Create locations. The IDs can be found in the documentation or retrieved
# with the LocationCriterionService.
my $california = Google::Ads::AdWords::v201802::Location->new({id => 21137});
push @criteria, $california;
my $mexico = Google::Ads::AdWords::v201802::Location->new({id => 2484});
push @criteria, $mexico;

# Create languages. The IDs can be found in the documentation or retrieved
# with the ConstantDataService.
my $english = Google::Ads::AdWords::v201802::Language->new({id => 1000});
push @criteria, $english;
my $spanish = Google::Ads::AdWords::v201802::Language->new({id => 1003});
push @criteria, $spanish;

# Create operations.
my @operations = ();
foreach my $criterion (@criteria) {
  my $operation =
    Google::Ads::AdWords::v201802::CampaignCriterionOperation->new({
      operator => "ADD",
      operand  => Google::Ads::AdWords::v201802::CampaignCriterion->new({
          campaignId => $campaign_id,
          criterion  => $criterion
        })});
  push @operations, $operation;
}

# Set campaign criteria.
my $result =
  $client->CampaignCriterionService()->mutate({operations => \@operations});

# Display campaign criteria.
if ($result->get_value()) {
  foreach my $campaign_criterion (@{$result->get_value()}) {
    printf "Campaign criterion of type '%s' and ID %s was added.\n",
      $campaign_criterion->get_criterion()->get_type(),
      $campaign_criterion->get_criterion()->get_id();
  }
}
    

Ruby

campaign_criterion_service =
    adwords.service(:CampaignCriterionService, API_VERSION)

criteria = [
  {
    :xsi_type => 'Location',
    :id => 21137 # California
  },
  {
    :xsi_type => 'Location',
    :id => 2484 # Mexico
  },
  {
    :xsi_type => 'Language',
    :id => 1000 # English
  },
  {
    :xsi_type => 'Language',
    :id => 1003 # Spanish
  }
]

operations = criteria.map do |criterion|
  {
    :operator => 'ADD',
    :operand => {
      :campaign_id => campaign[:id],
      :criterion => criterion
    }
  }
end

response = campaign_criterion_service.mutate(operations)

if response and response[:value]
  # Display the added campaign targets.
  response[:value].each do |criterion|
    puts 'Campaign criteria of type "%s" and id %d was added.' % [
        criterion[:criterion][:criterion_type],
        criterion[:criterion][:id]
    ]
  end
end
    

Relatórios

As estatísticas da campanha universal para apps estão disponíveis no Relatório de desempenho de campanhas. Você pode filtrar usando o advertisingChannelType e o advertisingChannelSubType, conforme mostrado a seguir:

string query = "Select CampaignId, CampaignName, Clicks,
   Impressions, Cost from CAMPAIGN_PERFORMANCE_REPORT where
   AdvertisingChannelType = MULTI_CHANNEL and
   AdvertisingChannelSubType = UNIVERSAL_APP_CAMPAIGN during
   LAST_7_DAYS";

string fileName = ExampleUtilities.GetHomeDir() + Path.DirectorySeparatorChar +
    "CampaignPerformanceReport.gz";

ReportUtilities utilities = new ReportUtilities(user, "v201802", query,
    DownloadFormat.GZIPPED_CSV.ToString());
utilities.GetResponse().Save(fileName);

Também é possível ver as estatísticas dos seguintes relatórios:

Exemplos de código

Veja, em cada biblioteca cliente, exemplos de código completos para adicionar uma Campanha universal para apps:

Campanhas de engajamento com apps para dispositivos móveis

O foco de campanhas de engajamento com apps para dispositivos móveis é aumentar o engajamento do usuário com seu aplicativo. O objetivo desse subtipo de campanha é fazer com que as pessoas que instalaram seu aplicativo o utilizem novamente ou o abram e realizem uma ação específica.

Esta seção explica como criar uma campanha de engajamento com apps para dispositivos móveis, criar anúncios para seu aplicativo para dispositivos móveis e monitorar o desempenho da campanha usando a Google AdWords API.

Os exemplos de código são em C#. Veja abaixo exemplos em outras linguagens.

Criar um orçamento de campanha

Para criar uma campanha, primeiro é necessário ter um orçamento. Você pode criar um Budget usando BudgetService ou escolher um orçamento compartilhado existente. O snippet de código a seguir mostra como criar um orçamento de US$ 5 por dia com entrega padrão:

// Get the BudgetService.
AdWordsUser user = new AdWordsUser();
BudgetService budgetService =
    (BudgetService) user.GetService(AdWordsService.v201802.BudgetService);

// Create the campaign budget.
Budget budget = new Budget();
budget.name = "My App Budget 1";
budget.deliveryMethod = BudgetBudgetDeliveryMethod.STANDARD;
budget.amount = new Money();
budget.amount.microAmount = 500000;

BudgetOperation budgetOperation = new BudgetOperation();
budgetOperation.@operator = Operator.ADD;
budgetOperation.operand = budget;

BudgetReturnValue budgetRetval = budgetService.mutate(
    new BudgetOperation[] {budgetOperation});
budget = budgetRetval.value[0];

Criar uma campanha

Depois de criar um orçamento, você pode criar uma campanha de engajamento com apps para dispositivos móveis com CampaignService.

No entanto, antes de criar sua campanha, é necessário selecionar uma rede de publicidade e estratégia de lances.

Selecionar uma rede de publicidade

Ao escolher uma rede de publicidade, você decide o público-alvo que deseja alcançar com a sua campanha:

  • Na Rede de Pesquisa, os anúncios são exibidos nos resultados da pesquisa em smartphones e tablets que já têm seu aplicativo instalado.
  • Na Rede de Display, os anúncios são exibidos dentro de outros aplicativos, especificamente para pessoas que já instalaram seu aplicativo.

Nos dois casos, os anúncios de engajamento no app podem incentivar os usuários atuais do seu aplicativo a interagir com ele.

Escolher uma estratégia de lances

Há várias formas de definir um lance para seus anúncios. Na BiddingStrategyConfiguration, no nível da Campaign, biddingStrategyType define o tipo de lance. Já biddingScheme contém os metadados da estratégia de lances.

Lances para a Rede de Pesquisa

Para a Rede de Pesquisa, as seguintes estratégias de lances são compatíveis:

Nome descritivo Tipo de estratégia de lances de API Estratégia de lances de API
Maximizar cliques (padrão) TARGET_SPEND TargetSpendBiddingScheme
Custo por aquisição (CPA) desejado TARGET_CPA TargetCpaBiddingScheme
Retorno do investimento em publicidade desejado TARGET_ROAS TargetRoasBiddingScheme
Definir posição na página de pesquisa PAGE_ONE_PROMOTED PageOnePromotedBiddingScheme
Parcela de superação desejada TARGET_OUTRANK_SHARE TargetOutrankShareBiddingScheme
CPC (custo por clique) manual MANUAL_CPC ManualCpcBiddingScheme
Lances para a Rede de Display

Para a Rede de Display, as seguintes estratégias de lances são compatíveis:

Nome descritivo Tipo de estratégia de lances de API Estratégia de lances de API
Foco em cliques (padrão) – use lances máximos de CPC MANUAL_CPC ManualCpcBiddingScheme
Foco em instalações – use lances de CPA TARGET_CPA TargetCpaBiddingScheme

Criar uma campanha da Rede de Pesquisa

Para criar uma campanha da Rede de Pesquisa, altere os campos advertisingChannelType e networkSetting da campanha, conforme mostrado abaixo.

A NetworkSetting define as redes que a campanha segmentará. Definir as opções targetGoogleSearch e targetSearchNetwork como true segmentará apenas a rede de pesquisa.

campaign.advertisingChannelType = AdvertisingChannelType.SEARCH;

campaign.networkSetting = new NetworkSetting();
campaign.networkSetting.targetGoogleSearch = true;
campaign.networkSetting.targetSearchNetwork = true;
campaign.networkSetting.targetContentNetwork = false;
campaign.networkSetting.targetPartnerSearchNetwork = false;

Na interface do usuário do Google AdWords, você especifica seu aplicativo no nível da campanha (em Configurações). Assim, você não precisará especificá-lo cada vez que criar um novo anúncio. Não há uma configuração equivalente na API. Você precisará especificar um código de aplicativo para cada anúncio de engajamento no app que criar.

Criar campanha da Rede de Display

Na Rede de Display, a otimização de conversões não estará disponível como opção enquanto sua campanha não registrar conversões suficientes.

O snippet de código a seguir mostra como criar uma campanha de engajamento com apps para dispositivos móveis da Rede de Display. Para focar no engajamento com apps para dispositivos móveis, defina advertisingChannelSubType da campanha como DISPLAY_MOBILE_APP.

// Get the CampaignService.
AdWordsUser user = new AdWordsUser();
CampaignService campaignService =
     (CampaignService) user.GetService(AdWordsService.v201802.CampaignService);

Campaign campaign = new Campaign();
campaign.advertisingChannelType = AdvertisingChannelType.DISPLAY;
campaign.advertisingChannelSubType =
    AdvertisingChannelSubType.DISPLAY_MOBILE_APP;
// Recommendation: Set the campaign to PAUSED when creating it to stop
// the ads from immediately serving. Set to ENABLED once you've added
// targeting and the ads are ready to serve.
campaign.status = CampaignStatus.PAUSED;

campaign.name = "My App Engagement campaign 1";

BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();
biddingConfig.biddingStrategyType = BiddingStrategyType.TARGET_CPA;

// Specify a BiddingScheme with a target CPA.
TargetCpaBiddingScheme biddingScheme =  new TargetCpaBiddingScheme();
biddingScheme.targetCpa = new Money();
biddingScheme.targetCpa.microAmount = 1000000;
biddingConfig.biddingScheme = biddingScheme;
campaign.biddingStrategyConfiguration = biddingConfig;

// Use the ID of the Budget created in the previous step. You can also
// reuse an existing budget.
campaign.budget = new Budget();
campaign.budget.budgetId = budget.budgetId;

// Optional: Set the campaign ad serving optimization status.
campaign.adServingOptimizationStatus =
    AdServingOptimizationStatus.CONVERSION_OPTIMIZE;

// Create the operation.
CampaignOperation operation = new CampaignOperation();
operation.@operator = Operator.ADD;
operation.operand = campaign;

// Add the campaign.
CampaignReturnValue retVal = campaignService.mutate(new CampaignOperation[] {operation});

Campaign newCampaign = retVal.value[0];

Criar um grupo de anúncios

Configure um AdGroup para os anúncios nesta campanha usando o AdGroupService.

Primeiro, crie o grupo de anúncios.

// Get the AdGroupService.
AdWordsUser user = new AdWordsUser();
AdGroupService adGroupService =
    (AdGroupService) user.GetService(AdWordsService.v201802.AdGroupService);

// Create the ad group.
AdGroup adGroup = new AdGroup();
adGroup.name = "My App Engagement adgroup 1";
adGroup.status = AdGroupStatus.ENABLED;
adGroup.campaignId = campaign.id;

Agora, defina os lances do grupo de anúncios. O parâmetro biddingStrategyConfiguration do grupo especifica quanto você quer pagar por clique ou aquisição. A BiddingStrategyConfiguration herda a estratégia de lances definida no nível da campanha.

// Set the ad group bids.
BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();

CpaBid cpaBid = new CpaBid();
cpaBid.bid = new Money();
cpaBid.bid.microAmount = 10000000;

biddingConfig.bids = new Bids[] {cpaBid};

adGroup.biddingStrategyConfiguration = biddingConfig;

Veja aqui alguns exemplos de como definir uma restrição de segmentação em um grupo de anúncios na Rede de Display.

// Optional: Set targeting restrictions.
// These settings only affect serving for the Display Network.
TargetingSetting targetingSetting = new TargetingSetting();

TargetingSettingDetail placementDetail = new TargetingSettingDetail();
placementDetail.criterionTypeGroup = CriterionTypeGroup.PLACEMENT;
placementDetail.targetAll = true;

targetingSetting.details = new TargetingSettingDetail[] {
    placementDetail};

adGroup.settings = new Setting[] {targetingSetting};

// Optional: Set the bidding group. This allows you to set absolute bids on
// this dimension. These settings only affect serving for the Display Network.
adGroup.contentBidCriterionTypeGroup =
CriterionTypeGroup.USER_INTEREST_AND_LIST;

// Create the operation.
AdGroupOperation operation = new AdGroupOperation();
operation.@operator = Operator.ADD;
operation.operand = adGroup;

// Create the ad group.
AdGroupReturnValue retVal = adGroupService.mutate(new AdGroupOperation[]
{adGroup});
AdGroup newAdGroup = retVal.value[0];

O Google AdWords pode mostrar seus anúncios de instalação de apps da Rede de Display em canais de anúncios de websites para dispositivos móveis e em canais de anúncios no aplicativo. Assim, seus anúncios têm ainda mais alcance e você ainda atinge seu custo por instalação desejado. Ative esse recurso com optimizerSetting:

ExplorerAutoOptimizerSetting optimizerSettings = new ExplorerAutoOptimizerSetting();
optimizerSetting.optin = true;

adGroup.settings = new Setting[] {optimizerSetting};

Lembre-se de adicionar pelo menos um critério de segmentação para celulares no grupo de anúncios para que essa configuração funcione.

Criar anúncios

Depois de criar seus grupos de anúncios, você pode criar anúncios de engajamento no app. É necessário configurar a segmentação adequada para que seus anúncios de engajamento no app sejam exibidos apenas para as pessoas que já instalaram seu aplicativo. Quando alguém clica no seu anúncio, ele abre o aplicativo e direciona a pessoa à atividade do aplicativo que você tiver especificado com seu link profundo.

  • Na Rede de Pesquisa, você pode usar esses anúncios para direcionar as pessoas ao local do seu aplicativo mais relacionado ao que elas pesquisaram no Google. A Rede de Pesquisa não é compatível com engajamento no app para anúncios iOS no momento.
  • Na Rede de Display, você pode usar esses anúncios para exibir textos incentivando um tipo específico de ação no seu aplicativo, como fazer check-in, fazer uma compra ou reservar um voo. Os anúncios podem servir como link profundo para levar os usuários a um local específico no seu aplicativo ou simplesmente iniciar o aplicativo no seu estado mais recente.

Anúncios de engajamento no app exigem um link profundo como URL final. Links profundos não são configurados automaticamente quando você cria seu aplicativo. Para campanhas de engajamento com apps na Rede de Pesquisa, o sistema gera um URI de aplicativo usando seu link profundo para que seus anúncios sejam compatíveis com a Pesquisa Google. Para saber como criar um link profundo, consulte estes guias:

Depois que você configurar seus links diretos, eles serão representados no URL final do seu aplicativo da seguinte forma:

android-app://{package_id}/{scheme}/{rest_of_url}

ou

ios-app://{app_id}/{scheme}/{rest_of_url}

Por exemplo, um link profundo como demogame://loadlevel?level=mars no aplicativo com.example.demogame seria representado no URL do seu anúncio desta forma:

android-app://com.example.demogame/demogame/loadlevel?level=mars

Para saber mais sobre os formatos de links diretos, consulte estes guias:

O snippet de código abaixo mostra como criar um anúncio de engajamento no app usando AdGroupAdService. Anúncios de engajamento no app para campanhas da Rede de Pesquisa usam o modelo 453. Anúncios de instalação do app para campanhas da Rede de Display usam modelos 445 (para anúncios de texto) ou 455 (para anúncios gráficos).

AdWordsUser user = new AdWordsUser();
AdGroupAdService adGroupAdService =
    (AdGroupAdService) user.GetService(AdWordsService.v201802.AdGroupAdService);
    // Create the template ad.
TemplateAd appEngagementAd = new TemplateAd();

appEngagementAd.displayUrl = "play.google.com";

appEngagementAd.name = "Ad for demo game";
appEngagementAd.templateId = 445;

// Define the ad's URL. You can refer to
// https://developers.google.com/app-indexing/webmasters/server
// for the right formatting to use on Android.
// Refer to https://developers.google.com/app-indexing/ios/app
// for the right formatting to use on iOS.
// Only one URL is allowed in the finalAppUrls array.
appEngagementAd.finalAppUrls = new string[] {
    "android-app://com.example.demogame/demogame/loadlevel?level=mars" };

// Create the template elements for the ad. You can refer to
// https://developers.google.com/adwords/api/docs/appendix/templateads
// for the list of available template fields.
TemplateElementField headline = new TemplateElementField();
headline.name = "promoHeadline";
headline.fieldText = "New levels are available";
headline.type = TemplateElementFieldType.TEXT;

TemplateElementField description = new TemplateElementField();
description.name = "promoDescription";
description.fieldText = "Race against players online";
description.type = TemplateElementFieldType.TEXT;

TemplateElementField appId = new TemplateElementField();
appId.name = "appId";
appId.fieldText = "com.example.demogame";
appId.type = TemplateElementFieldType.TEXT;

TemplateElementField appStore = new TemplateElementField();
appStore.name = "appStore";
appStore.fieldText = "2";
appStore.type = TemplateElementFieldType.ENUM;

TemplateElementField callToActionOpen = new TemplateElementField();
callToActionOpen.name = "callToActionOpen";
callToActionOpen.fieldText = "Play Now";
callToActionOpen.type = TemplateElementFieldType.TEXT;

TemplateElementField layout = new TemplateElementField();
layout.name = "layout";
layout.fieldText = "dark";
layout.type = TemplateElementFieldType.ENUM;

TemplateElement adData = new TemplateElement();
adData.uniqueName = "adData";
adData.fields = new TemplateElementField[] {headline, description, appId,
    appStore, callToActionInstall, callToActionOpen, layout};

appEngagementAd.dimensions = new Dimensions() {
    width = 320,
    height = 480
};

appEngagementAd.templateElements = new TemplateElement[] {adData};

// Finally, we get to tie the ad to the AdGroup!
// An AdGroupAd is a container that ties an ad to an
// AdGroup in the AdWords API.
AdGroupAd appEngagementAdAppAdGroupAd = new AdGroupAd();
appEngagementAdAdGroupAd.adGroupId = adGroupId;
appEngagementAdAppAdGroupAd.ad = appEngagementAd;

 // Create the operation.
 AdGroupAdOperation operation = new AdGroupAdOperation();
 operation.@operator = Operator.ADD;
 operation.operand = appEngagementAdAppAdGroupAd;

// Send the command to create the ad.
// The command returns the successfully created ad.
AdGroupAdReturnValue retval = adGroupAdService.mutate(
    new AdGroupAdOperation[] {operation});
AdGroupAd newAd = retval.value[0];

Anúncios gráficos de engajamento no app e anúncios de reengajamento no aplicativo também podem ser criados com a Google AdWords API. Consulte nossa página de documentação de modelos de anúncios para mais detalhes sobre campos.

Criar lista de usuário para segmentação (necessário para a Rede de Display)

Para campanhas de engajamento com apps para dispositivos móveis da Rede de Display, é necessário segmentar sua campanha somente para os usuários que têm seu aplicativo usando a segmentação por lista de usuários. Para configurar automaticamente uma lista de usuários composta pelas pessoas que têm seu aplicativo instalado, vincule sua conta do Google Play à sua conta do Google AdWords. Essa ação cria automaticamente uma lista de usuários de todas as pessoas que têm seu aplicativo instalado. Você também tem a opção de criar outras listas de usuários mais granulares na sua conta do Google AdWords usando AdwordsUserListService. Depois de definir suas listas de usuários, segmente cada grupo de anúncios para uma lista.

Segmentar anúncios

Depois de criar os anúncios, é possível adicionar critérios de segmentação para especificar para quem exibir o anúncio.

Segmentação na Rede de Pesquisa (opcional)

Na Rede de Pesquisa, é possível adicionar palavras-chave que correspondem aos termos de pesquisa usados pelas pessoas que procuram recursos de aplicativos como o seu na Pesquisa Google.

Um critério de grupo de anúncios pode ser criado usando AdGroupCriterionService. O snippet de código a seguir mostra como adicionar mars race event como palavra-chave na sua campanha e usar seu URL final para carregar uma corrida no seu aplicativo.

AdWordsUser user = new AdWordsUser();
AdGroupCriterionService adGroupCriterionService =
    (AdGroupCriterionService) user.GetService(
        AdWordsService.v201802.AdGroupCriterionService);

// Create the keyword.
Keyword keyword = new Keyword();
keyword.text = "mars race event";
keyword.matchType = KeywordMatchType.BROAD;

// Create the biddable ad group criterion.
BiddableAdGroupCriterion keywordCriterion = new BiddableAdGroupCriterion();
keywordCriterion.adGroupId = adGroupId;
keywordCriterion.criterion = keyword;

// Optional: Set the keyword final url.
keywordCriterion.finalAppUrls = new string[] {
    "android-app://com.example.demogame/loadevent/mars/megarace" };

// Create the operations.
AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
operation.@operator = Operator.ADD;
operation.operand = keywordCriterion;

// Create the keywords.
AdGroupCriterionReturnValue criteriaRetVal = adGroupCriterionService.mutate(
    new AdGroupCriterionOperation[] {operation});

Segmentação na Rede de Display (obrigatório)

Caso seu anúncio esteja na Rede de Display, segmente os usuários que têm seu aplicativo instalado usado a segmentação de listas de usuários. Essa segmentação é criada da mesma maneira por meio do AdGroupCriterionService, mas usando o tipo CriterionUserList.

Segmentação por público-alvo

Você interage com os usuários existentes do seu aplicativo criando uma lista de usuários de remarketing e usando-a como um critério de segmentação. Os anúncios de engajamento no app precisam ser segmentados para os usuários existentes do seu aplicativo.

O snippet de código a seguir mostra como recuperar a lista de usuários criada na sua conta do Google AdWords. Se você vinculou sua conta do Google Play à sua conta do Google AdWords, uma lista já foi criada e preenchida para você. Basta segmentá-la. Em caso negativo, siga estas instruções para configurar uma lista de usuários.

Este snippet de código mostra como recuperar uma lista de usuários existentes pelo nome.

AdWordsUser user = new AdWordsUser();
AdwordsUserListService userListService =
    (AdwordsUserListService)
         user.GetService(AdWordsService.v201802.AdwordsUserListService);

Selector selector = new Selector() {
    fields = new string[] { "Id", "Name", "ListType"},
    predicates = new Predicate[] {
        new Predicate() {
            field = "Name",
            @operator = PredicateOperator.EQUALS,
            values = new string[] {"All users of Demo App (Google Play)"}
        }
    }
};

UserListPage page = userListService.get(selector);
UserList myUserList = page.values[0];

Em seguida, você pode usar a instância UserList para modificar as configurações de segmentação ou os lances personalizados.

Definir lances personalizados

Por padrão, seus critérios usam os lances do nível do grupo de anúncios. No entanto, você também pode definir lances personalizados no nível do critério usando sua própria lógica de lances personalizados.

Lances personalizados da Rede de Display

Para ativar lances personalizados no nível do critério nas campanhas da Rede de Display, é necessário ativá-los primeiro no nível do grupo de anúncios especificando a dimensão na qual você deseja ativá-los.

O snippet de código a seguir define esse valor como PLACEMENT para que você tenha lances personalizados nos seus critérios Placement.

// Get the AdGroupService.
AdWordsUser user = new AdWordsUser();
AdGroupService adGroupService = (AdGroupService) user.GetService(
    AdWordsService.v201802.AdGroupService);

// Create the ad group.
AdGroup adGroup = new AdGroup();

// Optional: Set the bidding group. This allows you to set absolute bids on
// this dimension. This setting only affects serving for the Display Network.
adGroup.contentBidCriterionTypeGroup = CriterionTypeGroup.PLACEMENT;
adGroup.id = adGroupId;

// Create the operation.
AdGroupOperation operation = new AdGroupOperation();
operation.@operator = Operator.SET;
operation.operand = adGroup;

// Update the ad group.
AdGroupReturnValue adGroupRetVal = adGroupService.mutate(
   new AdGroupOperation[] {operation});

Em seguida, é possível atualizar os lances dos critérios usando AdGroupCriterionService. Este snippet de código define um lance personalizado de US$ 6 por aquisição para um canal.

// Get the AdGroupCriterionService.
AdGroupCriterionService adGroupCriterionService =
    (AdGroupCriterionService) user.GetService(
         AdWordsService.v201802.AdGroupCriterionService);

// Since we are not updating any placement-specific fields, it is enough to
// create a criterion object. The placementId, in this case,
// is a pre-existing Placement targeting a website.
Criterion criterion = new Criterion();
criterion.id = placementId;

// Create ad group criterion.
BiddableAdGroupCriterion biddableAdGroupCriterion =
    new BiddableAdGroupCriterion();
biddableAdGroupCriterion.adGroupId = adGroupId;
biddableAdGroupCriterion.criterion = criterion;

// Create the bids.
BiddingStrategyConfiguration biddingConfig =
     new BiddingStrategyConfiguration();
CpaBid cpcBid = new CpaBid();
cpaBid.bid = new Money();
cpaBid.bid.microAmount = 6000000;
biddingConfig.bids = new Bids[] {cpaBid};

biddableAdGroupCriterion.biddingStrategyConfiguration = biddingConfig;

// Create the operation.
AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
operation.@operator = Operator.SET;
operation.operand = biddableAdGroupCriterion;

// Update the placement.
AdGroupCriterionReturnValue agcRetVal = adGroupCriterionService.mutate(
    new AdGroupCriterionOperation[] {operation});

Acompanhar o desempenho da campanha

Depois de configurar sua campanha de anúncios, convém acompanhar a eficácia dela. A Google AdWords API é compatível com vários tipos de relatório para acompanhar o desempenho da sua campanha.

O seguinte snippet de código mostra como gerar um Relatório de desempenho de campanha para acompanhar o desempenho da sua campanha:

string query = "SELECT CampaignId, Conversions, Cost, Impressions from
CAMPAIGN_PERFORMANCE_REPORT DURING LAST_7_DAYS";

string filePath = ExampleUtilities.GetHomeDir() + Path.DirectorySeparatorChar
    + "CampaignPerformanceReport.gz";

ReportUtilities utilities = new ReportUtilities(user, "v201802", query,
    DownloadFormat.GZIPPED_CSV.ToString());
utilities.GetResponse().Save(fileName);

Para medir como os usuários interagem com seu aplicativo, configure conversões no aplicativo. Crie um acompanhamento de conversões no aplicativo seguindo as instruções em Como configurar o acompanhamento de conversões. Consulte as instruções em Acompanhamento de conversões no aplicativo para acompanhar as interações dos usuários no seu aplicativo como conversões.

Exemplos de código

Enviar comentários sobre…

Precisa de ajuda? Acesse nossa página de suporte.