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 deren 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 festlegen. 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);
    

C#

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

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

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

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

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

Python

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

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

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

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

PHP

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

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

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

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

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

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

    

Perl

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

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

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

Ruby

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

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

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

2. Kampagne erstellen

Erstellen Sie nun Ihre universelle App-Kampagne. Dabei gibt es folgende 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 sonstige 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.
  4. Für Version v201082 und höher müssen Sie beim Erstellen der universalAppSetting der Kampagne die appVendor-Eigenschaft angeben. Der Wert dieser Eigenschaft wird in älteren Versionen basierend auf der appId-Eigenschaft abgeleitet.

Java

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

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

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

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

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

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

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

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

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

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

C#

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

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

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

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

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

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

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

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

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

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

Python

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

budget_id = CreateBudget(client)

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

PHP

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

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

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

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

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

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

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

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

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

Perl

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

my $budgetId = create_budget($client);

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

Ruby

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

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

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

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

3. 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.labpixies.colordrips");
universalAppSetting.setAppVendor(MobileApplicationVendor.VENDOR_GOOGLE_MARKET);
universalAppSetting.setDescription1("A cool puzzle game");
universalAppSetting.setDescription2("Remove connected blocks");
universalAppSetting.setDescription3("3 difficulty levels");
universalAppSetting.setDescription4("4 colorful fun skins");

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

C#

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

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

Python

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

PHP

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

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

Perl

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

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

Ruby

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

4. 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 Felds 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});
    

C#

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

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

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

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

Python

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

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

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

PHP

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

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

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

Perl

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

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

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

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

Ruby

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

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

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

universal_app_campaign[:settings] = [
  universal_app_setting,
  geo_setting
]
    

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

C#

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

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

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

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

Python

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

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

PHP

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

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

Perl

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

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

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

Ruby

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

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

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

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

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

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

  response = campaign_criterion_service.mutate(operations)

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

if __FILE__ == $0
  API_VERSION = :v201802

  begin
    add_universal_app_campaigns()

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

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

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

    

Medien hochladen

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

Java

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

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

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

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

C#

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

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

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

Python

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

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

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

PHP

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

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

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

Perl

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

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

Ruby

media_srv = adwords.service(:MediaService, API_VERSION)

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

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

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

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.

Ein Beispiel: 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].

Targeting

Bei 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 = new ArrayList<>(Arrays.asList(california, mexico, english, spanish));

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

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

  operation.setOperator(Operator.ADD);

  operations.add(operation);
}

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

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

C#

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

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

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

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

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

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

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

    operations.Add(operation);
  }

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

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

Python

campaign_criterion_service = client.GetService('CampaignCriterionService')

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

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

response = campaign_criterion_service.mutate(operations)

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

PHP

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

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

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

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

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

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

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

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

Perl

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

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

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

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

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

Ruby

campaign_criterion_service =
    adwords.service(:CampaignCriterionService, API_VERSION)

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

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

response = campaign_criterion_service.mutate(operations)

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

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, "v201802", query,
    DownloadFormat.GZIPPED_CSV.ToString());
utilities.GetResponse().Save(fileName);

Statistiken sind auch in den folgenden Berichten enthalten:

Codebeispiele

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

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.v201802.BudgetService);

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

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

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

Kampagne erstellen

Nachdem Sie ein Budget festgelegt 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 Campaign-Ebene 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

Suchnetzwerk-Kampagne erstellen

Ändern Sie zum Erstellen einer Suchnetzwerk-Kampagne 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 festlegen, 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 Kampagnenebene (in Einstellungen) an, damit Sie sie 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.

Displaynetzwerk-Kampagne 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 Displaynetzwerk-Kampagne mit App-Interaktionsanzeigen 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.v201802.CampaignService);

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

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

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

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

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

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

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

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

Campaign newCampaign = retVal.value[0];

Anzeigengruppe erstellen

Richten Sie mithilfe des Dienstes AdGroupService ein AdGroup-Objekt 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.v201802.AdGroupService);

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

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 eine noch höhere Reichweite für Ihre Anzeigen und halten gleichzeitig den angestrebten 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 eingerichtet 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 Deeplink 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 (Deeplink) oder sie setzen die App wieder in den letzten Status zurück.

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

Nachdem Ihre Deeplinks 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 Deeplink wie demogame://loadlevel?level=mars in der App com.example.demogame würde beispielsweise in Ihrer Anzeigen-URL so aussehen:

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

Weitere Informationen zu Deeplink-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 Suchnetzwerk-Kampagnen verwenden die Vorlage 453. App-Installationsanzeigen für Displaywerk-Kampagnen verwenden die Vorlage 445 (für Textanzeigen) oder 455 (für Bildanzeigen).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Auch App-Interaktions-Bildanzeigen 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)

Bei Displayneztwerk-Kampagnen mit App-Interaktionsanzeigen 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 ausgeliefert werden sollen.

Ausrichtung auf das 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 dessen finale URL zum Laden eines Rennens in Ihrer App verwenden:

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

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

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

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

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

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

Ausrichtung im Displaynetzwerk (erforderlich)

Wenn Ihre Anzeige im Displaynetzwerk ausgeliefert 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 beschrieben 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.v201802.AdwordsUserListService);

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

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

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 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 Displaynetzwerk-Kampagnen 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.v201802.AdGroupService);

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

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

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

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

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.v201802.AdGroupCriterionService);

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

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

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

biddableAdGroupCriterion.biddingStrategyConfiguration = biddingConfig;

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

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

Kampagnenleistung analysieren

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

Das folgende Code-Snippet zeigt, wie Sie den Bericht Kampagnenleistung generieren, um die Leistung Ihrer Kampagne anzusehen:

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

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

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

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