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, comece criando um orçamento. As campanhas universais para apps não são compatíveis com orçamentos compartilhados. Sendo assim, você precisa definir a propriedade isExplicitlyShared do orçamento 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);
    

.NET

// Get the BudgetService.
BudgetService budgetService =
  (BudgetService) user.GetService(AdWordsService.v201609.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='v201609')

# 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

// Get the BudgetService, which loads the required classes.
$budgetService = $user->GetService('BudgetService', ADWORDS_VERSION);

// Create the shared budget (required).
$budget = new Budget();
$budget->name = 'Interplanetary Cruise Budget #' . uniqid();
$budget->amount = new Money(50000000);
$budget->deliveryMethod = 'STANDARD';

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

// Create operation.
$operation = new BudgetOperation();
$operation->operand = $budget;
$operation->operator = 'ADD';
$operations[] = $operation;

// Make the mutate request.
$result = $budgetService->mutate($operations);
$budget = $result->value[0];

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

Perl

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

my $budget_operation = Google::Ads::AdWords::v201609::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 manter as seguintes restrições em mente ao criar uma campanha universal para apps:

  1. O advertisingChannelType da campanha precisa ser definido como MULTI_CHANNEL, e advertisingChannelSubType como UNIVERSAL_APP_CAMPAIGN.
  2. Apenas o tipo de estratégia de lances TARGET_CPA é compatível.
  3. Muitas das configurações em campanhas normais, como networkSetting, frequencyCap e trackingUrlTemplate, não podem ser definidas em campanhas universais para apps. Consulte os documentos de referência para ver uma lista completa de configurações que não podem ser definidas.

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"));
    

.NET

// Get the CampaignService.
CampaignService campaignService =
  (CampaignService) user.GetService(AdWordsService.v201609.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='v201609')

budget_id = CreateBudget(client)

# Create the Universal App campaign.
universal_app_campaign = {
    'name': 'Interplanetary Cruise App #%s' % uuid.uuid4(),
    '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

// Get the CampaignService, which loads the required classes.
$campaignService = $user->GetService('CampaignService', ADWORDS_VERSION);

// Create campaign with some properties set.
$campaign = new Campaign();
$campaign->name = '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->status = 'PAUSED';

// Set the advertising channel and subchannel types for Universal app
// campaigns.
$campaign->advertisingChannelType = 'MULTI_CHANNEL';
$campaign->advertisingChannelSubType = 'UNIVERSAL_APP_CAMPAIGN';

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

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

$biddingStrategyConfiguration->biddingScheme = $biddingScheme;
$campaign->biddingStrategyConfiguration = $biddingStrategyConfiguration;

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

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

// Optional: Set the end date.
$campaign->endDate = 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::v201609::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::v201609::BiddingStrategyConfiguration->new({
        biddingStrategyType => "TARGET_CPA",
        # Set the target CPA to $1 / app install.
        biddingScheme =>
          Google::Ads::AdWords::v201609::TargetCpaBiddingScheme->new({
            targetCpa => Google::Ads::AdWords::v201609::Money->new(
              {microAmount => 1000000})})}
      ),
    # Budget (required) - note only the budgetId is required.
    budget =>
      Google::Ads::AdWords::v201609::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.interplanetarycruise.booking");
universalAppSetting.setDescription1("Best Space Cruise Line");
universalAppSetting.setDescription2("Visit all the planets");
universalAppSetting.setDescription3("Trips 7 days a week");
universalAppSetting.setDescription4("Buy your tickets now!");

// Optional: You can set up to 10 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 });
    

.NET

// Set the campaign's assets and ad text ideas. These values will be used to
// generate ads.
UniversalAppCampaignSetting universalAppSetting = new UniversalAppCampaignSetting();
universalAppSetting.appId = "com.interplanetarycruise.booking";
universalAppSetting.description1 = "Best Space Cruise Line";
universalAppSetting.description2 = "Visit all the planets";
universalAppSetting.description3 = "Trips 7 days a week";
universalAppSetting.description4 = "Buy your tickets now!";

// Optional: You can set up to 10 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.interplanetarycruise.booking',
        'description1': 'Best Space Cruise Line',
        'description2': 'Visit all the planets',
        'description3': 'Trips 7 days a week',
        'description4': 'Buy your tickets now!',
        # Optional: You can set up to 10 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->appId = 'com.interplanetarycruise.booking';
$universalAppSetting->description1 = 'Best Space Cruise Line';
$universalAppSetting->description2 = 'Visit all the planets';
$universalAppSetting->description3 = 'Trips 7 days a week';
$universalAppSetting->description4 = 'Buy your tickets now!';

// Optional: You can set up to 10 image assets for your campaign.
// See UploadImage.php for an example on how to upload images.
//
// $universalAppSetting->imageMediaIds = array(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::v201609::UniversalAppCampaignSetting->new({
    appId        => "com.interplanetarycruise.booking",
    description1 => "Best Space Cruise Line",
    description2 => "Visit all the planets",
    description3 => "Trips 7 days a week",
    description4 => "Buy your tickets now!"
  });

# Optional: You can set up to 10 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.interplanetarycruise.booking',
  :description1 => 'Best Space Cruise Line',
  :description2 => 'Visit all the planets',
  :description3 => 'Trips 7 days a week',
  :description4 => 'Buy your tickets now!'
  # Optional: You can set up to 10 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: com universalAppBiddingStrategyGoalType, você pode especificar um tipo de meta ao otimizar a estratégia de lances da campanha. Quando você seleciona o tipo de meta de estratégia de lances como OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME, 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 acompanhadores de conversões.

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});
    

.NET

// 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->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 = array(
//     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->negativeGeoTargetType = 'LOCATION_OF_PRESENCE';
$campaign->settings = array($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::v201609::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::v201609::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);
}
    

.NET

// 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 the campaign operation.
$operations = array();
$operation = new CampaignOperation();
$operation->operand = $campaign;
$operation->operator = 'ADD';
$operations[] = $operation;

// Add campaigns on the server.
$result = $campaignService->mutate($operations);

// Print information for each campaign.
foreach ($result->value as $campaign) {
  printf("Universal App Campaign with name '%s' and ID %d was added.\n",
      $campaign->name, $campaign->id);
  // Optional: Set the campaign's location and language targeting. No other
  // targeting criteria can be used for Universal App campaigns.
  SetCampaignTargetingCriteria($campaign->id, $user);
}
    

Perl

# Create operation.
my $campaign_operation =
  Google::Ads::AdWords::v201609::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 = :v201609

  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é 10 recursos de imagens em Campanhas universais para apps. Esses recursos serão utilizados pelo Google AdWords para criar 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("http://goo.gl/HJM3L"));
image.setType(MediaMediaType.IMAGE);

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

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

.NET

MediaService mediaService = (MediaService) user.GetService(
    AdWordsService.v201609.MediaService);

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

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

Python

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

with open(image_filename, 'r') as image_handle:
  image_data = base64.encodestring(image_handle.read())

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

PHP

$mediaService = $user->GetService('MediaService', ADWORDS_VERSION);

// Create image.
$image = new Image();
$image->data = MediaUtils::GetBase64Data('http://goo.gl/HJM3L');
$image->type = 'IMAGE';

// Make the upload request.
$result = $mediaService->upload(array($image));
    

Perl

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

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

Ruby

media_srv = adwords.service(:MediaService, API_VERSION)

# Create image.
image_url =
    'http://www.google.com/intl/en/adwords/select/images/samples/inline.jpg'
# This utility method retrieves the contents of a URL using all of the config
# options provided to the Api object.
image_data = AdsCommon::Http.get(image_url, adwords.config)
base64_image_data = Base64.encode64(image_data)
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 campos da lista, como imageMediaIds. ListOperations descreve o comportamento de elementos em uma lista e sempre será definido em alguma lista em um objeto da API (por exemplo imageMediaIdsOps descreve como atualizar 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 = Lists.<Criterion>newArrayList(california, mexico, english, spanish);

// Create operations to add each of the criteria above.
List<CampaignCriterionOperation> operations = Lists.<CampaignCriterionOperation>newArrayList();
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());
  }
}
    

.NET

// Get the CampaignCriterionService.
CampaignCriterionService campaignCriterionService =
  (CampaignCriterionService) user.GetService(
    AdWordsService.v201609.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

// Get the service, which loads the required classes.
$campaignCriterionService =
    $user->GetService('CampaignCriterionService', ADWORDS_VERSION);

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

$mexico = new Location();
$mexico->id = 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->id = 1000;
$campaignCriteria[] = new CampaignCriterion($campaignId, null, $english);

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

// Create operations to add each of the criteria above.
$operations = array();
foreach ($campaignCriteria as $campaignCriterion) {
  $operations[] = new CampaignCriterionOperation($campaignCriterion, 'ADD');
}

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

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

Perl

# Create locations. The IDs can be found in the documentation or retrieved
# with the LocationCriterionService.
my $california = Google::Ads::AdWords::v201609::Location->new({id => 21137});
push @criteria, $california;
my $mexico = Google::Ads::AdWords::v201609::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::v201609::Language->new({id => 1000});
push @criteria, $english;
my $spanish = Google::Ads::AdWords::v201609::Language->new({id => 1003});
push @criteria, $spanish;

# Create operations.
my @operations = ();
foreach my $criterion (@criteria) {
  my $operation =
    Google::Ads::AdWords::v201609::CampaignCriterionOperation->new({
      operator => "ADD",
      operand  => Google::Ads::AdWords::v201609::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 por meio do Relatório de desempenho de campanhas. Você pode filtrar pelo advertisingChannelType e advertisingChannelSubType da campanha, 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, "v201609", query,
    DownloadFormat.GZIPPED_CSV.ToString());
utilities.GetResponse().Save(fileName);

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

  • BUDGET_PERFORMANCE_REPORT
  • CAMPAIGN_LOCATION_TARGET_REPORT
  • CAMPAIGN_NEGATIVE_LOCATIONS_REPORT
  • ACCOUNT_PERFORMANCE_REPORT

Exemplos de código

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

As campanhas de instalações de apps para dispositivos móveis do Google AdWords são um subtipo de campanha otimizado para incentivar mais pessoas a fazer o download do seu aplicativo para dispositivos móveis.

Esta seção explica como criar campanhas de instalações de apps para dispositivos móveis e anúncios para seu aplicativo para dispositivos móveis. Além disso, ela mostra como monitorar o desempenho da campanha usando a Google AdWords API.

Criar um orçamento de campanha

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

// Get the BudgetService.
BudgetService budgetService =
    (BudgetService) user.GetService(AdWordsService.v201609.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 = 5000000;

// Create the operation.
BudgetOperation budgetOperation = new BudgetOperation();
budgetOperation.@operator = Operator.ADD;
budgetOperation.operand = budget;

// Add the 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 instalações de apps para dispositivos móveis com CampaignService.

Mas primeiro você precisa decidir o público-alvo que deseja alcançar com sua campanha. Para isso, selecione uma rede de publicidade e uma estratégia de lances.

Selecionar uma rede de publicidade

  • Na Rede de Pesquisa, você pode exibir anúncios de instalação de apps para as pessoas quando elas estão em busca de um aplicativo como o seu ou tentando fazer algo que seu aplicativo facilita.
  • Na Rede de Display, é possível alcançar pessoas enquanto elas usam outros aplicativos semelhantes ao seu. Essas campanhas geralmente recebem grandes volumes de impressões, que podem aumentar o reconhecimento do seu aplicativo e atrair novos usuários de aplicativos que não estejam procurando ativamente por você.

Na interface da Web do Google AdWords, você especifica seu aplicativo no nível da campanha (em Configurações). Assim, não precisa especificá-lo novamente sempre que criar um novo anúncio. Não há uma configuração equivalente na API. Você precisará especificar um código do aplicativo para cada anúncio de instalação do app que criar. Consulte Criar anúncios abaixo para mais detalhes.

Escolher uma estratégia de lances

Na Rede de Pesquisa, as campanhas de instalações de apps para dispositivos móveis são compatíveis com estas estratégias de lances:

A Rede de Display é compatível com estas estratégias de lances:

As instalações de aplicativos para Android no Google Play são acompanhadas automaticamente como conversões. Sendo assim, recomendamos que você use CPA desejado com estratégia de lances. Você pode definir um lance de CPA desejado que corresponda ao valor do custo por instalação (CPI) do seu aplicativo. O sistema otimizará seus lances para ajudar você a conseguir o maior número possível de downloads. Também é possível definir lances específicos para seus grupos de anúncios ou para critérios de segmentação individuais.

Este snippet de código mostra como criar uma campanha de instalação de aplicativos para a Rede de Display:

// Get the CampaignService.
CampaignService campaignService =
     (CampaignService) user.GetService(AdWordsService.v201609.CampaignService);

Campaign campaign = new Campaign();
campaign.advertisingChannelType = AdvertisingChannelType.DISPLAY;
// 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;

// Set the advertising channel subtype for mobile app install campaigns.
campaign.advertisingChannelSubType = AdvertisingChannelSubType.DISPLAY_MOBILE_APP;

campaign.name = "My App 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.ROTATE;

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

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

Campaign newCampaign = retVal.value[0];

A criação de uma campanha para a Rede de Pesquisa é semelhante. A principal diferença é que você precisa definir um valor diferente para os campos advertisingChannelType, advertisingChannelSubType e networkSetting:

campaign.advertisingChannelType = AdvertisingChannelType.SEARCH;
campaign.advertisingChannelSubType = AdvertisingChannelSubType.SEARCH_MOBILE_APP;

// Target the networks you want your ads to serve on.
campaign.networkSetting = new NetworkSetting();
campaign.networkSetting.targetGoogleSearch = true;
campaign.networkSetting.targetSearchNetwork = true;

Criar um grupo de anúncios

Você precisa criar um grupo de anúncios na sua campanha usando AdGroupService.

A configuração biddingStrategyConfiguration do grupo de anúncios é importante, pois especifica o valor que você deseja pagar nos seus anúncios por clique ou aquisição. O exemplo de código abaixo usa uma estratégia de lances de US$ 10 por aquisição.

// Get the AdGroupService.
AdGroupService adGroupService =
    (AdGroupService) user.GetService(AdWordsService.v201609.AdGroupService);

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

// 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;

// 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};

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

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

Criar anúncios

Depois de configurar os grupos de anúncios, crie anúncios de instalação de apps (anúncios clique para fazer o download) na sua campanha. Para facilitar os downloads, esses anúncios são vinculados à página do seu aplicativo na loja de aplicativos.

Os anúncios de instalação de apps podem ser criados nestes formatos:

  • Anúncios de instalação de apps (anúncios clique para fazer o download) são gerados automaticamente. Criamos esse anúncio usando o ícone do aplicativo e os comentários sobre ele na Google Play Store ou na Apple Store. Esse formato está disponível na Rede de Pesquisa e na Rede de Display.

  • Anúncios gráficos de instalação de apps são criados com o upload de uma imagem e o preenchimento do seu texto para criar um anúncio de instalação do app personalizado com seus próprios elementos gráficos atraentes. Esse formato só está disponível na Rede de Display.

  • Anúncios em vídeo de instalação de apps são anúncios em vídeo na Rede de Display criados usando um link da sua conta do YouTube ou gerados automaticamente com imagens, ícones e comentários sobre seu aplicativo.

Use AdGroupAdService para criar um anúncio clique para fazer o download:

AdGroupAdService adGroupAdService =
    (AdGroupAdService) user.GetService(AdWordsService.v201609.AdGroupAdService);

// Create the template ad.
TemplateAd clickToDownloadAppAd = new TemplateAd();

clickToDownloadAppAd.name = "Ad for demo game";
clickToDownloadAppAd.templateId = 353;
clickToDownloadAppAd.url =
    "http://play.google.com/store/apps/details?id=com.example.demogame123";
clickToDownloadAppAd.displayUrl = "play.google.com";

// 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 = "headline";
headline.fieldText = "Enjoy your drive in Mars";
headline.type = TemplateElementFieldType.TEXT;

TemplateElementField description1 = new TemplateElementField();
description1.name = "description1";
description1.fieldText = "Realistic physics simulation";
description1.type = TemplateElementFieldType.TEXT;

TemplateElementField description2 = new TemplateElementField();
description2.name = "description2";
description2.fieldText = "Race against players online";
description2.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;

TemplateElement adData = new TemplateElement();
adData.uniqueName = "adData";
adData.fields = new TemplateElementField[] {headline, description1,
    description2, appId, appStore};

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

// Create the adgroupad.
AdGroupAd clickToDownloadAppAdGroupAd = new AdGroupAd();
clickToDownloadAppAdGroupAd.adGroupId = adGroupId;
clickToDownloadAppAdGroupAd.ad = clickToDownloadAppAd;

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

// Create the ad.
AdGroupAdReturnValue adRetval = adGroupAdService.mutate(
    new AdGroupAdOperation[] {operation});
AdGroupAd newAd = retval.value[0];

Você também pode criar um anúncio gráfico ou em vídeo de instalação do app por meio da API. Consulte nossa documentação de anúncios de modelo para ver os campos relevantes.

Segmentar anúncios

Depois de criar seus anúncios, adicione critérios de segmentação para especificar para quem exibi-los. Na Rede de Pesquisa, você pode adicionar palavras-chave que correspondem a termos de pesquisa usados pelas pessoas que procuram aplicativos como o seu na Pesquisa Google e no Google Play.

É possível criar um critério de grupo de anúncios usando AdGroupCriterionService.

O snippet de código a seguir mostra como adicionar "android race game" como palavra-chave na sua campanha:

AdGroupCriterionService adGroupCriterionService =
    (AdGroupCriterionService) user.GetService(
        AdWordsService.v201609.AdGroupCriterionService);

// Create the keyword.
Keyword keyword = new Keyword();
keyword.text = "android race game";
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.finalUrls = new string[] {
    "http://play.google.com/store/apps/demogame123" };

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

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

Há muitas outras opções de segmentação disponíveis na Rede de Display. Elas são criadas da mesma maneira usando AdGroupCriterionService, mas empregam um tipo de Criterion diferente.

Categorias de aplicativos para dispositivos móveis

Você pode especificar categorias de aplicativos para dispositivos móveis nas quais exibir seus anúncios. Por exemplo, é possível definir sua segmentação para incluir certos tipos de aplicativo, como "Jogos" ou "Saúde". O snippet de código a seguir mostra como segmentar seu aplicativo para exibir anúncios nos aplicativos "Jogos" do Google Play.

MobileAppCategory category = new MobileAppCategory();
category.mobileAppCategoryId = 60008;

Consulte a página de categorias de aplicativos para dispositivos móveis e veja a lista completa dessas categorias compatíveis.

Aplicativos carregados anteriormente

É possível mostrar anúncios para pessoas que já fizeram o download de outros aplicativos na categoria que você deseja segmentar. Para esse tipo de segmentação, você pode optar por exibir anúncios somente para pessoas que compraram um aplicativo ou pagaram por uma compra no aplicativo na categoria segmentada. O snippet de código a seguir mostra como segmentar seu aplicativo somente para usuários que instalaram pelo menos um aplicativo pago da categoria "Quebra-cabeças".

// Target paid users. The list of valid IDs for this criteria can be found on
// https://developers.google.com/adwords/api/docs/reference/latest/AdGroupCriterionService.AppPaymentModel
AppPaymentModel paymentModel = new AppPaymentModel();
paymentModel.id = 30;

// Create the biddable ad group criterion.
BiddableAdGroupCriterion paymentModelCriterion = new BiddableAdGroupCriterion();
paymentModelCriterion.adGroupId = adGroupId;
paymentModelCriterion.criterion = paymentModel;

// Target users interested in Puzzle Games. See
// https://developers.google.com/adwords/api/docs/appendix/mobileappcategories for the list
// of valid IDs.
CriterionUserInterest userInterest = new CriterionUserInterest();
userInterest.userInterestId = 87086;

// Create the biddable ad group criterion.
BiddableAdGroupCriterion userInterestCriterion = new BiddableAdGroupCriterion();
userInterestCriterion.adGroupId = adGroupId;
userInterestCriterion.criterion = userInterest;

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

AdGroupCriterionOperation operation2 = new AdGroupCriterionOperation();
operation2.@operator = Operator.ADD;
operation2.operand = userInterestCriterion;

Consulte a lista de todos os interesses válidos do usuário em ConstantDataService:

CriterionUserInterest[] userInterests = constantDataService.getUserInterestCriterion(
    ConstantDataServiceUserInterestTaxonomyType.MOBILE_APP_INSTALL_USER);

Estes valores também estão disponíveis na página de categorias de aplicativos para dispositivos móveis.

Novos dispositivos móveis

Você pode segmentar anúncios para pessoas que ativaram smartphones recentemente e, portanto, podem ter interesse em adicionar novos aplicativos. Você pode escolher essa opção em categorias de interesse e selecionar o número de dias desde que o dispositivo foi ativado, de uma semana até três meses.

O snippet de código a seguir mostra como criar um critério CriterionUserInterest que segmenta usuários que ativaram um novo dispositivo nos últimos sete dias. Veja os códigos de interesse válidos do usuário na página de interesses do usuário de smartphone.

// Target users who activated a new device within the last 7 days. See
// https://developers.google.com/adwords/api/docs/appendix/smartphone-userinterest for the list
// of valid IDs.
CriterionUserInterest userInterest = new CriterionUserInterest();
userInterest.userInterestId = 85002;

// Create the biddable ad group criterion.
BiddableAdGroupCriterion userInterestCriterion = new BiddableAdGroupCriterion();
userInterestCriterion.adGroupId = adGroupId;
userInterestCriterion.criterion = userInterest;

userInterestCriterion.biddingStrategyConfiguration.bids = new Bids[] { cpcBid };

Segmentação demográfica

Você pode segmentar anúncios por informações demográficas, como idade ou sexo do público-alvo. O snippet de código a seguir mostra como segmentar usuários entre 18 e 24 anos.

AgeRange ageRange = new AgeRange();
ageRange.ageRangeType = AgeRangeAgeRangeType.AGE_RANGE_18_24;

Da mesma forma, você pode restringir por sexo adicionando um critério Gender.

Segmentação por dispositivo

Por padrão, seus anúncios serão exibidos em dispositivos compatíveis que não têm seu aplicativo instalado. Se você estiver segmentando a Rede de Display, poderá restringir para dispositivos, versões de sistema operacional ou operadoras específicas. A segmentação por dispositivo é definida no nível da campanha usando CampaignCriterionService.

O snippet de código a seguir mostra como restringir sua campanha para o Android Jelly Bean 4.1 ou posterior:

// Create the OS version restriction.
OperatingSystemVersion osVersion = new OperatingSystemVersion();
osVersion.id = 630257; // Android 4.1 Jelly Bean

CampaignCriterion osVersionCriterion = new CampaignCriterion();
osVersionCriterion.campaignId = campaignId;
osVersionCriterion.criterion = osVersion;

CampaignCriterionOperation operation = new CampaignCriterionOperation();
operation.@operator = Operator.ADD;
operation.operand = osVersionCriterion;

CampaignCriterionReturnValue campaignCriterionRetVal = campaignCriterionService.mutate(
    new CampaignCriterionOperation[] { operation });

A lista de versões do sistema operacional para dispositivos móveis suportadas está disponível na página de plataformas para dispositivos móveis ou por meio do ConstantDataService. Da mesma forma, também é possível restringir pelo critério dispositivo móvel ou operadora.

Definir lances personalizados

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

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. Essa etapa não é necessária para campanhas da Rede de Pesquisa. O snippet de código a seguir define esse valor para PLACEMENT. Assim, você pode usar lances personalizados no seu critério Placement:

// Get the AdGroupService.
AdGroupService adGroupService = (AdGroupService) user.GetService(
    AdWordsService.v201609.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.

O snippet de código a seguir define um lance personalizado de US$ 3 por clique para um canal:

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

// Since we are not updating any placement-specific fields, it is enough to
// create a criterion object.
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();

// You may use CpaBid instead of CpcBid if your campaign uses
// a cost-per-acquisition bidding strategy.
CpcBid cpcBid = new CpcBid();
cpcBid.bid = new Money();
cpcBid.bid.microAmount = 3000000;
biddingConfig.bids = new Bids[] {cpcBid};

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});

Acompanhamento de conversões

Depois de configurar sua campanha de anúncios, acompanhe a eficácia dela. As campanhas de instalações de apps para dispositivos móveis foram criadas para acompanhar downloads do seu aplicativo como conversões. Existem dois tipos de conversão de aplicativos relacionados à instalação de aplicativo:

  1. Instalações de aplicativo (do Google Play):
  2. Instalações de aplicativo (primeiro acesso):
    • Disponível em aplicativos para Android e iOS
    • appConversionType de FIRST_OPEN (Android) ou DOWNLOAD (iOS)

Além disso, você pode acompanhar ações no aplicativo para Android usando appConversionType do IN_APP_PURCHASE.

Mais informações sobre conversões de aplicativos podem ser encontradas no guia de acompanhamento de conversões e nos artigos da Central de Ajuda do Google AdWords sobre acompanhamento de conversões em aplicativos para Android e iOS.

Relatórios

Você pode recuperar as estatísticas de conversão da sua campanha usando um Relatório de desempenho de campanhas. O seguinte snippet de código mostra como gerar um:

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

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

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

Consulte a página de relatórios para ver uma lista dos tipos de relatório compatíveis.

A partir da v201603, CAMPAIGN_PERFORMANCE_REPORT inclui estatísticas de Campanhas universais para apps. Essas campanhas podem ser identificadas ao filtrar por AdvertisingChannelType = MULTI_CHANNEL e AdvertisingChannelSubType = UNIVERSAL_APP_CAMPAIGN, conforme mostrado abaixo:

string query = "SELECT CampaignId, Conversions, Cost, Impressions " +
    "from CAMPAIGN_PERFORMANCE_REPORT where " +
    "AdvertisingChannelType = MULTI_CHANNEL and " +
    "AdvertisingChannelSubType = UNIVERSAL_APP_CAMPAIGN DURING LAST_7_DAYS";

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

Levar em consideração atrasos de conversões

Os números das conversões podem levar alguns dias para aparecer nos relatórios devido às interações atrasadas entre o dispositivo de uma pessoa, o Google e os serviços de acompanhamento de terceiros que você usa. Quando você analisar os relatórios de conversão, os três dias anteriores dos dados de conversão poderão não estar completos ainda.

Exemplos de código

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, é necessário primeiro 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 com entrega padrão de US$ 5 por dia:

// Get the BudgetService.
AdWordsUser user = new AdWordsUser();
BudgetService budgetService =
    (BudgetService) user.GetService(AdWordsService.v201609.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 os seus anúncios. Em 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.

NetworkSetting define as redes que a campanha segmentará. A definição das 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.v201609.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 AdGroupService.

Primeiro, crie o grupo de anúncios.

// Get the AdGroupService.
AdWordsUser user = new AdWordsUser();
AdGroupService adGroupService =
    (AdGroupService) user.GetService(AdWordsService.v201609.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. 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.v201609.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.v201609.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 usando AdGroupCriterionService, mas com 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.v201609.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 para 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.v201609.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.v201609.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, "v201609", 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.