Kampagnen für mobile Apps

In diesem Leitfaden wird beschrieben, wie Sie die folgenden Arten von Kampagnen für mobile Apps erstellen und konfigurieren sowie ihre Leistung überwachen:

Universelle App-Kampagnen

Mit einer universellen App-Kampagne können Sie einfach für Ihre Android- oder iOS-Apps bei Google Play, in der Google-Suche, auf YouTube und im Google Displaynetzwerk werben. In diesem Leitfaden erfahren Sie, wie Sie eine solche Kampagne erstellen, die Ausrichtung festlegen und Berichte generieren.

Kampagne erstellen

1. Budget festlegen

Vor dem Erstellen einer universellen App-Kampagne müssen Sie ein Budget erstellen. Universelle App-Kampagnen unterstützen keine gemeinsamen Budgets. Daher müssen Sie die Property isExplicitlyShared auf false festlegen.

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]
    

Weitere Informationen finden Sie in unserem Leitfaden für Kampagnenbudgets.

2. Kampagne erstellen

Erstellen Sie nun Ihre Kampagne. Beim Erstellen einer universellen App-Kampagne gibt es die folgenden Einschränkungen:

  1. Der advertisingChannelType der Kampagne muss auf MULTI_CHANNEL und der advertisingChannelSubType auf UNIVERSAL_APP_CAMPAIGN festgelegt werden.
  2. Es wird nur der Gebotsstrategietyp TARGET_CPA unterstützt.
  3. Viele der Einstellungen für normale Kampagnen wie networkSetting, frequencyCap und trackingUrlTemplate können bei universellen App-Kampagnen nicht festgelegt werden. Eine vollständige Liste aller Einstellungen, die nicht möglich sind, finden Sie in der Referenzdokumentation.

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. Anzeigen anpassen

In universellen App-Kampagnen können Nutzer keine Anzeigen erstellen (wie es bei anderen Kampagnentypen der Fall ist). Stattdessen werden Anzeigen in mehreren Formaten und für mehrere Werbenetzwerke unter Berücksichtigung Ihres Eintrags im App Store, zusätzlicher Textideen und der in den Kampagneneinstellungen angegebenen Assets generiert. Das folgende Snippet zeigt, wie Sie die Assets Ihrer Kampagne festlegen.

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. Kampagne optimieren

Sie können die Kampagne mithilfe von zwei Einstellungen optimieren. Mit universalAppBiddingStrategyGoalType geben Sie beim Optimieren der Gebotsstrategie der Kampagne einen Zielvorhabentyp an. Wenn Sie den Zielvorhabentyp der Gebotsstrategie auf OPTIMIZE_FOR_INSTALL_CONVERSION_VOLUME festlegen, können Sie die Optimierung auch mithilfe des Feldes selectiveOptimization für eine Reihe von In-App-Conversion-Typen durchführen. Mit dem ConversionTrackerService können Sie eine Liste aller Conversion-Tracker abrufen.

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
]
    

Erstellen Sie zum Abschluss die Kampagne mithilfe der Methode 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

    

Medien hochladen

Für eine universelle App-Kampagne können Sie bis zu zehn Bildassets angeben. Diese Assets werden von AdWords zum Erstellen von Anzeigen verwendet. Zum Hochladen von Bildern können Sie die Methode MediaService.upload verwenden.

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])
    

Mit ListOperations arbeiten

In universellen App-Kampagnen werden ListOperations zum Festlegen von Listenfeldern wie imageMediaIds verwendet. Mit ListOperations wird das Verhalten von Elementen in einer Liste beschrieben. Dieser Typ wird immer zusammen mit einer Liste in einem API-Objekt definiert. So beschreibt beispielsweise imageMediaIdsOps, wie imageMediaIds aktualisiert werden soll. Die Anzahl der Operatoren in ListOperations muss mit der Anzahl der Elemente in der entsprechenden Liste übereinstimmen. Von jedem Operator wird in Verbindung mit seinem entsprechenden Listenelement eine beabsichtigte Änderung beschrieben.

Angenommen, imageMediaIds enthielt anfangs die Werte [1000, 1001, 1002]. Die Tabelle unten zeigt einen mutate-Aufruf zum Aktualisieren von imageMediaIds mit ListOperations.

Elementindex Bild-Media-ID ListOperation Bedeutung
0 1003 PUT Element-ID "1003" wird hinzugefügt, weil sie in der ursprünglichen Liste fehlte.
1 1002 REMOVE Element-ID "1002" wird entfernt.

Nach dem mutate-Aufruf enthält imageMediaIds die Werte [1000, 1001, 1003].

Ausrichtung

Von universellen App-Kampagnen werden nur zwei Ausrichtungskriterien unterstützt: Sprache und Standort auf Kampagnenebene. Standardmäßig sind Kampagnen auf alle Standorte und alle Sprachen ausgerichtet. Das folgende Code-Snippet zeigt, wie eine Kampagne auf Kalifornien und Mexiko sowie auf Englisch und Spanisch ausgerichtet wird.

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
    

Berichte

Statistiken zu universellen App-Kampagnen sind im Bericht "Kampagnenleistung" enthalten. Sie können wie folgt nach dem advertisingChannelType und advertisingChannelSubType der Kampagne filtern:

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

Statistiken sind auch in den folgenden Berichten enthalten:

  • BUDGET_PERFORMANCE_REPORT
  • CAMPAIGN_LOCATION_TARGET_REPORT
  • CAMPAIGN_NEGATIVE_LOCATIONS_REPORT
  • ACCOUNT_PERFORMANCE_REPORT

Codebeispiele

In jeder Clientbibliothek gibt es vollständige Codebeispiele zum Hinzufügen einer universellen App-Kampagne:

Eine AdWords-Kampagne mit App-Installationsanzeigen ist ein Kampagnenuntertyp, der dafür optimiert ist, dass mehr Nutzer Ihre mobile App herunterladen.

In diesem Abschnitt wird erläutert, wie Sie eine Kampagne mit App-Installationsanzeigen erstellen, Anzeigen für Ihre mobile App erstellen und die Kampagnenleistung mithilfe der AdWords API überwachen.

Kampagnenbudget erstellen

Vor dem Erstellen einer Kampagne benötigen Sie ein Budget. Sie können ein Budget mit BudgetService erstellen oder ein vorhandenes gemeinsames Budget auswählen. Das folgende Code-Snippet zeigt, wie Sie ein Budget mit normaler Auslieferung und 5 $ pro Tag erstellen:

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

Kampagne erstellen

Sobald Sie ein Budget erstellt haben, können Sie mit CampaignService eine Kampagne mit App-Installationsanzeigen erstellen.

Zunächst müssen Sie jedoch entscheiden, welche Zielgruppe Sie mit Ihrer Kampagne erreichen möchten. Wählen Sie dazu ein Werbenetzwerk und eine Gebotsstrategie aus.

Werbenetzwerk auswählen

  • Im Suchnetzwerk können Sie App-Installationsanzeigen für Nutzer schalten, die gerade nach einer App wie der Ihren suchen oder etwas tun möchten, was mit Ihrer App einfacher möglich ist.
  • Im Displaynetzwerk können Sie Nutzer erreichen, die gerade ähnliche Apps wie Ihre verwenden. Mit diesen Kampagnen werden häufig sehr viele Impressionen erzielt. Dadurch kann der Bekanntheitsgrad Ihrer App steigen und es werden möglicherweise Nutzer angesprochen, die nicht aktiv nach Ihrer App suchen.

In der AdWords-Web-Benutzeroberfläche geben Sie Ihre App auf der Kampagnenebene (in Einstellungen) an, damit Sie die App nicht jedes Mal beim Erstellen einer neuen Anzeige angeben müssen. In der API gibt es keine äquivalente Einstellung: Sie müssen für jede erstellte App-Installationsanzeige eine App-ID angeben. Weitere Informationen finden Sie unter Anzeigen erstellen.

Gebotsstrategie auswählen

Im Suchnetzwerk unterstützen Kampagnen mit App-Installationsanzeigen die folgenden Gebotsstrategien:

Im Displaynetzwerk werden diese Gebotsstrategien unterstützt:

Installationen von Android-Apps über Google Play werden automatisch als Conversions erfasst. Wir empfehlen daher für Kampagnen mit App-Installationsanzeigen die Verwendung von Ziel-CPA als Gebotsstrategie. Sie können ein Ziel-CPA-Gebot so festlegen, dass es dem CPI-Wert (Cost-per-Install) der App entspricht. Vom System werden Ihre Gebote dann so optimiert, dass Sie möglichst viele Downloads erzielen. Sie können auch individuelle Gebote für Anzeigengruppen oder einzelne Ausrichtungskriterien festlegen.

In diesem Code-Snippet wird die Erstellung einer Kampagne mit App-Installationsanzeigen für das Displaynetzwerk gezeigt:

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

Eine Kampagne für das Suchnetzwerk kann auf ähnliche Weise erstellt werden. Der Hauptunterschied besteht darin, dass Sie unterschiedliche Werte für die Felder advertisingChannelType, advertisingChannelSubType und networkSetting festlegen müssen:

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;

Anzeigengruppe erstellen

Eine Anzeigengruppe in Ihrer Kampagne muss mit AdGroupService erstellt werden.

Eine wichtige Einstellung in diesem Zusammenhang ist biddingStrategyConfiguration der Anzeigengruppe. Dieser Wert gibt an, wie viel Sie für Ihre Anzeigen pro Klick oder Akquisition bezahlen möchten. Entscheidend dafür ist die auf der Kampagnenebene ausgewählte Gebotsstrategie. Im folgenden Codebeispiel wird eine Gebotsstrategie von 10 $ pro Akquisition verwendet:

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

Anzeigen erstellen

Sobald Anzeigengruppen eingerichtet sind, können Sie App-Installationsanzeigen (Click-to-Download-Anzeigen) in Ihrer Kampagne erstellen. Um Downloads zu erleichtern, sind diese Anzeigen mit der Seite Ihrer App im App Store verknüpft.

App-Installationsanzeigen können in den folgenden Formaten erstellt werden:

  • App-Installationsanzeigen (Click-to-Download-Anzeigen) werden automatisch generiert. Wir erstellen Anzeigen dieses Formats unter Einbeziehung Ihres App-Symbols und der Rezensionen Ihrer App aus dem Google Play Store oder dem Apple Store. Dieses Anzeigenformat ist sowohl im Suchnetzwerk als auch im Displaynetzwerk verfügbar.

  • App-Installationsbildanzeigen werden erstellt, indem Sie ein Bild hochladen und den gewünschten Text eingeben. So entsteht eine benutzerdefinierte App-Installationsanzeige, die Ihre eigenen ansprechenden Bilder enthält. Dieses Format ist nur im Displaynetzwerk verfügbar.

  • App-Installationsvideoanzeigen sind Videoanzeigen im Displaynetzwerk, die mit einem Link aus Ihrem YouTube-Konto erstellt oder automatisch auf Grundlage von Bildern, Symbolen und Rezensionen Ihrer App generiert werden.

Verwenden Sie AdGroupAdService zum Erstellen einer Click-to-Download-Anzeige:

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

Über die AdWords API können Sie auch eine App-Installationsbild- oder -videoanzeige erstellen. Die relevanten Felder finden Sie auf der Seite für Anzeigenvorlagen.

Anzeigen ausrichten

Nachdem Sie Ihre Anzeigen erstellt haben, sollten Sie noch festlegen, wer sie sehen soll, indem Sie Ausrichtungskriterien hinzufügen. Im Suchnetzwerk können Sie Keywords hinzufügen, die von Nutzern verwendeten Suchbegriffen entsprechen, mit denen diese in der Google-Suche oder bei Google Play nach ähnlichen Apps wie Ihrer suchen.

Sie erstellen ein Anzeigengruppenkriterium mit AdGroupCriterionService.

Das folgende Code-Snippet zeigt, wie Sie Ihrer Kampagne "android race game" als Keyword hinzufügen:

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

Im Displaynetzwerk gibt es viel mehr Ausrichtungsoptionen. Sie werden ebenfalls mit AdGroupCriterionService erstellt, doch wird für Criterion ein anderer Typ verwendet.

Kategorien für mobile Apps

Sie können für mobile Apps Kategorien angeben, in denen Ihre Anzeigen geschaltet werden sollen. So haben Sie beispielsweise die Möglichkeit, die Ausrichtung auf bestimmte Arten von Apps wie etwa Spiele- oder Gesundheits-Apps festzulegen. Das folgende Code-Snippet zeigt, wie Sie Ihre App so ausrichten, dass sie bei Google Play unter Spiele-Apps zu finden ist:

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

Eine vollständige Liste der unterstützten Kategorien für mobile Apps finden Sie auf der Seite mit Kategorien für mobile Apps.

Bereits heruntergeladene Apps

Sie können Anzeigen für Nutzer schalten, die bereits andere Apps in einer Kategorie, auf die Sie ausrichten (Zielkategorie), heruntergeladen haben. Bei dieser Art der Ausrichtung können Sie festlegen, dass Ihre Anzeigen nur für Nutzer ausgeliefert werden, die in der Zielkategorie eine App gekauft oder für einen In-App-Kauf bezahlt haben. Das folgende Code-Snippet zeigt, wie Sie Ihre App nur auf Nutzer ausrichten, die mindestens eine bezahlte App aus der Kategorie "Puzzle Games" installiert haben.

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

Die Liste aller gültigen Nutzerinteressen können Sie mit dem Dienst ConstantDataService abrufen:

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

Diese Werte sind auch auf der Seite mit Kategorien für mobile Apps verfügbar.

Neue Mobilgeräte

Sie können Anzeigen auch für Nutzer schalten, die ihr Gerät erst vor Kurzem aktiviert haben und daher möglicherweise neue Apps installieren möchten. Diese Option ist in den Interessenkategorien verfügbar. Sie können auch festlegen, wie viel Zeit seit der Aktivierung des Geräts maximal verstrichen sein soll (Zeitraum zwischen einer Woche und drei Monaten wählbar).

Das folgende Code-Snippet zeigt, wie Sie ein CriterionUserInterest-Kriterium erstellen, mit dem auf Nutzer ausgerichtet wird, die innerhalb der letzten sieben Tage ein neues Gerät aktiviert haben. Die gültigen Nutzerinteressen-IDs finden Sie auf der Seite mit Smartphone-Nutzerinteressen.

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

Demografische Ausrichtung

Anzeigen können auch nach demografischen Merkmalen ausgerichtet werden, beispielsweise nach Alter oder Geschlecht der Zielgruppe. Das folgende Code-Snippet zeigt, wie Sie Anzeigen auf Nutzer zwischen 18 und 24 Jahren ausrichten:

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

Entsprechend können Sie das Geschlecht einschränken, indem Sie ein Gender-Kriterium hinzufügen.

Ausrichtung auf Geräte

Standardmäßig werden Ihre Anzeigen auf kompatiblen Geräten ausgeliefert, auf denen Ihre App noch nicht installiert ist. Wenn Sie Ihre Anzeigen auf das Displaynetzwerk ausrichten, können Sie die Ausrichtung auf bestimmte Geräte, Betriebssystemversionen oder Mobilfunkanbieter beschränken. Die Ausrichtung auf Geräte wird mithilfe von CampaignCriterionService auf Kampagnenebene festgelegt.

Das folgende Code-Snippet zeigt, wie Sie Ihre Kampagne auf Android Jelly Bean 4.1 oder höher beschränken:

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

Eine Liste der unterstützten mobilen Betriebssystemversionen ist auf der Seite mit mobilen Plattformen oder über ConstantDataService verfügbar. In ähnlicher Weise können Sie Kriterien zur Einschränkung nach Mobilgerät oder Mobilfunkanbieter festlegen.

Benutzerdefinierte Gebote festlegen

Standardmäßig verwenden Kriterien die Gebote auf der Anzeigengruppenebene. Mit eigener Logik können Sie jedoch benutzerdefinierte Gebote auch auf Kriteriumsebene festlegen.

Um benutzerdefinierte Gebote auf Kriteriumsebene für Kampagnen im Displaynetzwerk zu aktivieren, müssen Sie sie zunächst auf Anzeigengruppenebene aktivieren. Geben Sie dazu die Dimension an, für die Sie benutzerdefinierte Gebote aktivieren möchten. Dieser Schritt ist für Kampagnen im Suchnetzwerk nicht erforderlich. Das folgende Code-Snippet legt den Wert der Dimension auf PLACEMENT fest. Damit sind benutzerdefinierte Gebote für das Placement-Kriterium möglich.

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

Nun können Sie mit AdGroupCriterionService die Gebote für das Kriterium aktualisieren.

Das folgende Code-Snippet zeigt, wie für ein Placement ein benutzerdefiniertes Gebot von 3 $ pro Klick festgelegt wird:

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

Conversion-Tracking

Sobald Sie Ihre Kampagne eingerichtet haben, sollten Sie ihre Effizienz nachverfolgen. In Kampagnen mit App-Installationsanzeigen werden Downloads Ihrer App als Conversions erfasst. Es gibt zwei Arten von App-Conversions im Zusammenhang mit App-Installationen:

  1. App-Installationen (über Google Play):
  2. App-Installationen (erstes Öffnen):
    • Für Android- und iOS-Apps verfügbar
    • appConversionType ist FIRST_OPEN (Android) oder DOWNLOAD (iOS)

Außerdem können Sie mit appConversionType = IN_APP_PURCHASE In-App-Aktionen für Android nachverfolgen.

Weitere Informationen zu App-Conversions finden Sie im Leitfaden zum Conversion-Tracking und in den AdWords-Hilfeartikeln zum App-Conversion-Tracking für Android und iOS.

Berichte

Mit einem Bericht "Kampagnenleistung" können Sie Conversion-Statistiken für Ihre Kampagne abrufen. Das folgende Code-Snippet zeigt, wie dieser Bericht generiert wird:

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

Auf der Seite für Berichte finden Sie eine Liste der unterstützten Berichtstypen.

Seit Version 201603 enthält CAMPAIGN_PERFORMANCE_REPORT Statistiken für universelle App-Kampagnen. Diese Kampagnen können durch Filtern nach AdvertisingChannelType = MULTI_CHANNEL und AdvertisingChannelSubType = UNIVERSAL_APP_CAMPAIGN wie folgt identifiziert werden:

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

Conversion-Verzögerungen einplanen

Bei der Kommunikation zwischen dem Gerät des Nutzers, Google oder dem möglicherweise von Ihnen verwendeten Tracking von Drittanbietern kann es zu Verzögerungen kommen und somit einige Tage dauern, bis Conversion-Daten in Berichten sichtbar sind. Daher sind die Daten der letzten drei Tage in den Conversion-Berichten unter Umständen noch nicht vollständig.

Codebeispiele

Kampagnen mit App-Interaktionsanzeigen

Mithilfe von Kampagnen mit App-Interaktionsanzeigen können Sie die Interaktion von Nutzern mit Ihrer App steigern. Wenn Sie möchten, dass Nutzer, die Ihre App installiert haben, sie noch einmal ausprobieren oder öffnen und eine bestimmte Aktion ausführen, sind solche Kampagnen die richtige Wahl.

In diesem Abschnitt erfahren Sie, wie Sie eine Kampagne mit App-Interaktionsanzeigen sowie Anzeigen für Ihre App erstellen und die Leistung der Kampagne mithilfe der AdWords API überwachen.

Die Codebeispiele sind in C# geschrieben. Beispiele in anderen Programmiersprachen finden Sie unten.

Kampagnenbudget erstellen

Vor dem Erstellen einer Kampagne benötigen Sie ein Budget. Sie können ein Budget mit BudgetService erstellen oder ein vorhandenes gemeinsames Budget auswählen. Das folgende Code-Snippet zeigt, wie Sie ein Budget mit normaler Auslieferung und 5 $ pro Tag erstellen:

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

Kampagne erstellen

Nachdem Sie ein Budget erstellt haben, können Sie mit CampaignService eine Kampagne mit App-Interaktionsanzeigen erstellen.

Zuvor müssen Sie jedoch ein Werbenetzwerk und die Gebotsstrategie auswählen.

Werbenetzwerk auswählen

Durch die Auswahl eines Werbenetzwerks entscheiden Sie, welche Zielgruppe Sie mit Ihrer Kampagne erreichen möchten.

  • Im Suchnetzwerk werden Anzeigen in Suchergebnissen auf Smartphones und Tablets ausgeliefert, auf denen Ihre App bereits installiert ist.
  • Im Displaynetzwerk werden Anzeigen in anderen Apps bei Nutzern ausgeliefert, die Ihre App bereits installiert haben.

In beiden Fällen können App-Interaktionsanzeigen Ihre aktuellen App-Nutzer zu einer Interaktion mit Ihrer App animieren.

Gebotsstrategie auswählen

Es gibt mehrere Möglichkeiten, Gebote für Anzeigen abzugeben. In der BiddingStrategyConfiguration auf Kampagnenebene wird von biddingStrategyType der Typ des Gebots definiert, während biddingScheme die Metadaten der Gebotsstrategie enthält.

Gebote im Suchnetzwerk

Für das Suchnetzwerk werden die folgenden Gebotsstrategien unterstützt:

Beschreibender Name API-Gebotsstrategietyp API-Gebotsstrategie
Klicks maximieren (Standardeinstellung) TARGET_SPEND TargetSpendBiddingScheme
Ziel-CPA (Cost-per-Acquisition) TARGET_CPA TargetCpaBiddingScheme
Ziel-ROAS (Return on Advertising Spend) TARGET_ROAS TargetRoasBiddingScheme
Ausrichtung auf Suchseitenposition PAGE_ONE_PROMOTED PageOnePromotedBiddingScheme
Kompetitive Auktionsposition TARGET_OUTRANK_SHARE TargetOutrankShareBiddingScheme
Manueller CPC MANUAL_CPC ManualCpcBiddingScheme
Gebote im Displaynetzwerk

Für das Displaynetzwerk werden die folgenden Gebotsstrategien unterstützt:

Beschreibender Name API-Gebotsstrategietyp API-Gebotsstrategie
Schwerpunkt auf Klicks (Standardeinstellung) – maximale CPC-Gebote verwenden MANUAL_CPC ManualCpcBiddingScheme
Schwerpunkt auf Installationen – CPA-Gebote verwenden TARGET_CPA TargetCpaBiddingScheme

Kampagne für das Suchnetzwerk erstellen

Ändern Sie zum Erstellen einer Kampagne für das Suchnetzwerk die Felder advertisingChannelType und networkSetting wie unten gezeigt.

Mit NetworkSetting werden die Werbenetzwerke festgelegt, auf die die Kampagne ausgerichtet wird. Wenn Sie die Optionen targetGoogleSearch und targetSearchNetwork auf true einstellen, werden Ihre Anzeigen nur auf das Suchnetzwerk ausgerichtet.

campaign.advertisingChannelType = AdvertisingChannelType.SEARCH;

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

In der AdWords-Benutzeroberfläche geben Sie Ihre App auf der Kampagnenebene (in Einstellungen) an, damit Sie die App nicht jedes Mal beim Erstellen einer neuen Anzeige angeben müssen. In der API gibt es keine entsprechende Möglichkeit. Sie müssen daher für jede erstellte App-Interaktionsanzeige eine App-ID angeben.

Kampagne im Displaynetzwerk erstellen

Beim Displaynetzwerk ist die Option zur Optimierung bei Conversions erst verfügbar, wenn Ihre Kampagne genügend Conversions erzielt hat.

Im folgenden Code-Snippet wird gezeigt, wie Sie eine Kampagne mit App-Interaktionsanzeigen für das Displaynetzwerk erstellen. Um den Schwerpunkt auf die App-Interaktion zu legen, muss advertisingChannelSubType der Kampagne auf DISPLAY_MOBILE_APP eingestellt sein.

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

Anzeigengruppe erstellen

Richten Sie mithilfe von AdGroupService eine AdGroup (Anzeigengruppe) für die Anzeigen in dieser Kampagne ein.

Erstellen Sie zunächst die Anzeigengruppe.

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

Nun müssen die Anzeigengruppengebote festgelegt werden. Die Einstellung BiddingStrategyConfiguration der Gruppe legt fest, wie viel Sie pro Klick oder Akquisition bezahlen möchten. BiddingStrategyConfiguration übernimmt die auf Kampagnenebene festgelegte Gebotsstrategie.

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

Hier einige Beispiele, wie für eine Anzeigengruppe im Displaynetzwerk eine Ausrichtungseinschränkung festgelegt wird:

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

Ihre App-Installationsanzeigen für das Displaynetzwerk können vom AdWords-System außer in In-App-Anzeigen-Placements auch in Anzeigen-Placements auf mobilen Websites ausgeliefert werden. Sie erzielen damit eventuell noch mehr Reichweite für Ihre Anzeigen und halten gleichzeitig Ihren Ziel-Cost-per-Install ein. Aktivieren Sie diese Funktion mit optimizerSetting:

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

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

Sie müssen der Anzeigengruppe mindestens ein Kriterium zur Ausrichtung auf Mobilgeräte hinzufügen, damit diese Einstellung wirksam wird.

Anzeigen erstellen

Nachdem Sie Anzeigengruppen erstellt haben, können Sie App-Interaktionsanzeigen erstellen. Wichtig ist dabei, dass Sie die geeignete Ausrichtung verwenden, damit die App-Interaktionsanzeigen nur für Nutzer ausgeliefert werden, die Ihre App bereits installiert haben. Wenn ein Nutzer auf Ihre Anzeige klickt, wird die App geöffnet und die Aktivität Ihrer App ausgelöst, die Sie mit dem Deep-Link verbunden haben.

  • Im Suchnetzwerk können Sie mit diesen Anzeigen Nutzer an die Stelle in Ihrer App leiten, die besonders relevant für das bei Google Gesuchte ist. App-Interaktionen für iOS-Anzeigen im Suchnetzwerk werden derzeit nicht unterstützt.
  • Im Displaynetzwerk können Sie mit diesen Anzeigen Text präsentieren, der zu einer bestimmten Art von Aktion in Ihrer App motiviert, wie Einchecken, etwas kaufen oder einen Flug buchen. Über diese Anzeigen gelangen Nutzer entweder zu einer bestimmten Stelle in Ihrer App (Deep-Link) oder sie setzen die App wieder in den letzten Status zurück.

App-Interaktionsanzeigen benötigen einen Deep-Link als finale URL. Deep-Links werden beim Erstellen einer App nicht automatisch eingerichtet. Bei Kampagnen mit App-Interaktionsanzeigen im Suchnetzwerk wird vom System aus Ihrem Deep-Link eine App-URI generiert, sodass Ihre Anzeigen mit der Google-Suche kompatibel sind. Informationen zum Erstellen von Deep-Links finden Sie in den folgenden Leitfäden:

Nachdem Ihre Deep-Links eingerichtet sind, müssen sie in der finalen App-URL wie folgt eingebaut werden:

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

oder

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

Ein Deep-Link wie demogame://loadlevel?level=mars in der App com.example.demogame würde beispielsweise in Ihrer Anzeigen-URL wie folgt aussehen:

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

Weitere Informationen zu Deep-Link-Formaten finden Sie in den folgenden Leitfäden:

Das Code-Snippet unten zeigt, wie eine App-Interaktionsanzeige mit AdGroupAdService erstellt wird. App-Interaktionsanzeigen für Kampagnen im Suchnetzwerk verwenden Vorlage 453. App-Installationsanzeigen für Kampagnen im Suchnetzwerk verwenden Vorlage 445 (für Textanzeigen) oder 455 (für Bildanzeigen).

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

Auch App-Interaktionsbildanzeigen und Anzeigen zur erneuten Interaktion mit Apps können über die AdWords API erstellt werden. Eine ausführliche Beschreibung der Felder finden Sie auf der Dokumentationsseite für Anzeigenvorlagen.

Nutzerliste für Ausrichtung erstellen (für Displaynetzwerk erforderlich)

Für Kampagnen mit App-Interaktionsanzeigen im Displaynetzwerk müssen Sie die Kampagne auf Nutzer ausrichten, die Ihre App bereits installiert haben. Verwenden Sie dafür eine Nutzerliste. Verknüpfen Sie Ihr Google Play-Konto mit Ihrem AdWords-Konto, um automatisch eine Nutzerliste zu erstellen, in der alle Nutzer enthalten sind, die Ihre App bereits installiert haben. Mit AdwordsUserListService können Sie auch weitere, detailliertere Nutzerlisten in Ihrem AdWords-Konto erstellen. Anschließend richten Sie jede Anzeigengruppe auf eine Nutzerliste aus.

Anzeigen ausrichten

Sobald die Anzeigen erstellt sind, können Sie Ausrichtungskriterien hinzufügen, um festzulegen, für wen sie geschaltet werden sollen.

Ausrichtung im Suchnetzwerk (optional)

Im Suchnetzwerk können Sie Keywords hinzufügen, die zu Suchbegriffen passen, mit denen Nutzer in der Google-Suche nach Apps mit den von Ihrer App gebotenen Funktionen suchen.

Mit AdGroupCriterionService lässt sich ein Anzeigengruppenkriterium erstellen. Das folgende Code-Snippet zeigt, wie Sie mars race event (Rennveranstaltung auf dem Mars) Ihrer Kampagne als Keyword hinzufügen und seine finale URL zum Laden eines Rennens in Ihrer App verwenden:

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

Ausrichtung im Displaynetzwerk (erforderlich)

Wenn Ihre Anzeige im Displaynetzwerk geschaltet werden soll, müssen Sie sie auf Nutzer ausrichten, die Ihre App bereits installiert haben. Verwenden Sie dazu die Ausrichtung auf Nutzerlisten. Diese Ausrichtung wird ebenfalls mit AdGroupCriterionService erstellt, sie verwendet jedoch den Typ CriterionUserList.

Ausrichtung auf Zielgruppen

Sie interagieren mit bestehenden App-Nutzern, indem Sie eine Remarketing-Nutzerliste erstellen und diese Liste als Ausrichtungskriterium verwenden. App-Interaktionsanzeigen müssen auf bestehende Nutzer Ihrer App ausgerichtet sein.

Das folgende Code-Snippet zeigt, wie Sie eine in Ihrem AdWords-Konto erstellte Nutzerliste abrufen. Wenn Sie Ihr Google Play-Konto mit Ihrem AdWords-Konto verknüpft haben, wurde eine Liste bereits erstellt und automatisch gefüllt. Sie müssen Ihre Anzeige dann nur noch darauf ausrichten. Gehen Sie andernfalls wie in dieser Anleitung vor, um eine Nutzerliste einzurichten.

Dieses Code-Snippet zeigt, wie Sie eine vorhandene Nutzerliste anhand ihres Namens abrufen:

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

Sie können anschließend die Instanz UserList verwenden, um Ausrichtungseinstellungen zu ändern oder benutzerdefinierte Gebote einzurichten.

Benutzerdefinierte Gebote festlegen

Standardmäßig verwenden Kriterien die Gebote auf der Anzeigengruppenebene. Mit eigener Logik können Sie aber auch benutzerdefinierte Gebote auf Kriteriumsebene festlegen.

Benutzerdefinierte Gebote im Displaynetzwerk

Um benutzerdefinierte Gebote auf Kriteriumsebene für Kampagnen im Displaynetzwerk zu aktivieren, müssen Sie sie zunächst auf Anzeigengruppenebene aktivieren. Geben Sie dazu die Dimension an, für die Sie benutzerdefinierte Gebote aktivieren möchten.

Das folgende Code-Snippet setzt diesen Wert auf PLACEMENT. Damit sind jetzt benutzerdefinierte Gebote für das Placement-Kriterium möglich.

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

Nun können Sie mit AdGroupCriterionService die Gebote für das Kriterium aktualisieren. Mit diesem Code-Snippet wird ein benutzerdefiniertes Gebot von 6 $ pro Akquisition für ein Placement festgelegt:

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

Kampagnenleistung nachverfolgen

Sobald Sie Ihre Kampagne eingerichtet haben, sollten Sie ihre Effizienz nachverfolgen. Die AdWords API unterstützt mehrere Berichtstypen, mit denen das möglich ist.

Das folgende Code-Snippet zeigt, wie Sie einen Bericht "Kampagnenleistung" generieren, um die Leistung Ihrer Kampagne nachzuverfolgen:

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

Richten Sie In-App-Conversions ein, um zu messen, wie Nutzer mit Ihrer App interagieren. Erstellen Sie dazu einen Conversion-Tracker für In-App-Conversions anhand der Anleitung unter Conversion-Tracking einrichten. In der Anleitung unter App-Conversion-Tracking finden Sie Informationen, wie Sie Interaktionen von Nutzern in Ihrer App als Conversions erfassen.

Codebeispiele

Feedback geben zu...