Dynamische Suchanzeigen

Mit dynamischen Suchanzeigen können Sie Ihre Anzeigen auf komplette Websites oder Teile davon ausrichten, ohne Keywords und Anzeigenkopien für alle möglichen Übereinstimmungen erstellen zu müssen. Stattdessen wird vom System bei jeder relevanten Suche eines Nutzers dynamisch eine Anzeige mit einem Anzeigentitel generiert, der auf der Suchanfrage basiert. Der Anzeigentext richtet sich nach Ihrer relevantesten Zielseite. Die Anzeige nimmt an der Auktion teil und steht ganz normal im Wettbewerb. Dadurch erhalten Sie aufgrund der stärkeren Präsenz Ihres vorhandenen Inventars bessere Ergebnisse, ohne dass die vorhandenen Keyword-Kampagnen geändert werden.

Mit dynamischen Suchanzeigen können Sie Ihre Anzeigen nicht nur auf eine komplette Website oder Domain ausrichten. Dieser Anzeigentyp bietet zusätzlich die Möglichkeit, unkompliziert für vorhandene Kampagnen und Keywords sämtliche Suchanfragen entgegenzunehmen oder als Backupoption zu dienen. Richten Sie Keywords, Anzeigengruppen und Anzeigenkopien wie gewohnt ein und fügen Sie dann eine dynamische Suchanzeige hinzu, um so viele Suchanfragen wie möglich abzudecken, die nicht mit der Konfiguration Ihrer vorhandenen Kampagne übereinstimmen.

In diesem Leitfaden erfahren Sie, wie Sie dynamische Suchanzeigen mit der AdWords API erstellen und verwenden.

Dynamische Suchanzeigen erstellen

So richten Sie dynamische Suchanzeigen mit der API ein:

  1. Richten Sie eine Kampagne ein und legen Sie ihre Domain fest.
  2. Erstellen Sie eine Anzeigengruppe für Funktionen, die Bezug zu dynamischen Suchanzeigen haben.
  3. Erstellen Sie mindestens eine dynamische Suchanzeige.
  4. Geben Sie mindestens ein Kriterium für die Auslieferung der dynamischen Suchanzeigen in der Kampagne an.

Kampagne einrichten

Um dem AdWords-System mitzuteilen, dass Sie in Ihrer Kampagne dynamische Suchanzeigen verwenden werden, müssen Sie zuerst eine Kampagne erstellen, bei der advertisingChannelType auf SEARCH festgelegt ist. Außerdem muss eine Domain für die Auslieferung der dynamischen Suchanzeigen angegeben werden. Dies erreichen Sie, indem Sie für die settings-Property des Campaign-Objekts ein DynamicSearchAdsSetting-Objekt festlegen.

Im folgenden Beispiel wird eine Kampagne mit dynamischen Suchanzeigen erstellt.

C#

private static Campaign CreateCampaign(AdWordsUser user, Budget budget) {
  // Get the CampaignService.
  CampaignService campaignService =
    (CampaignService) user.GetService(AdWordsService.v201705.CampaignService);

  // Create a Dynamic Search Ads campaign.
  Campaign campaign = new Campaign();
  campaign.name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString();
  campaign.advertisingChannelType = AdvertisingChannelType.SEARCH;

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

  BiddingStrategyConfiguration biddingConfig = new BiddingStrategyConfiguration();
  biddingConfig.biddingStrategyType = BiddingStrategyType.MANUAL_CPC;
  campaign.biddingStrategyConfiguration = biddingConfig;

  campaign.budget = new Budget();
  campaign.budget.budgetId = budget.budgetId;

  // Required: Set the campaign's Dynamic Search Ads settings.
  DynamicSearchAdsSetting dynamicSearchAdsSetting = new DynamicSearchAdsSetting();
  // Required: Set the domain name and language.
  dynamicSearchAdsSetting.domainName = "example.com";
  dynamicSearchAdsSetting.languageCode = "en";

  // Set the campaign settings.
  campaign.settings = new Setting[] { dynamicSearchAdsSetting };

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

  // 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.
    Campaign newCampaign = retVal.value[0];
    Console.WriteLine("Campaign with id = '{0}' and name = '{1}' was added.",
      newCampaign.id, newCampaign.name);
    return newCampaign;
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to add campaigns.", e);
  }
}

Java

private static Campaign createCampaign(
    AdWordsServicesInterface adWordsServices, AdWordsSession session, Budget budget)
    throws RemoteException, ApiException {
  // Get the CampaignService.
  CampaignServiceInterface campaignService =
      adWordsServices.get(session, CampaignServiceInterface.class);

  // Create campaign.
  Campaign campaign = new Campaign();
  campaign.setName("Interplanetary Cruise #" + System.currentTimeMillis());
  campaign.setAdvertisingChannelType(AdvertisingChannelType.SEARCH);

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

  BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration();
  biddingStrategyConfiguration.setBiddingStrategyType(BiddingStrategyType.MANUAL_CPC);
  campaign.setBiddingStrategyConfiguration(biddingStrategyConfiguration);

  // Only the budgetId should be sent, all other fields will be ignored by CampaignService.
  Budget campaignBudget = new Budget();
  campaignBudget.setBudgetId(budget.getBudgetId());
  campaign.setBudget(campaignBudget);

  // Required: Set the campaign's Dynamic Search Ads settings.
  DynamicSearchAdsSetting dynamicSearchAdsSetting = new DynamicSearchAdsSetting();
  // Required: Set the domain name and language.
  dynamicSearchAdsSetting.setDomainName("example.com");
  dynamicSearchAdsSetting.setLanguageCode("en");

  // Set the campaign settings.
  campaign.setSettings(new Setting[] {dynamicSearchAdsSetting});

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

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

  // Add the campaign.
  Campaign newCampaign = campaignService.mutate(new CampaignOperation[] {operation}).getValue(0);

  // Display the results.
  System.out.printf(
      "Campaign with name '%s' and ID %d was added.%n",
      newCampaign.getName(), newCampaign.getId());

  return newCampaign;
}

Python

campaign_service = client.GetService('CampaignService')

operations = [{
    'operator': 'ADD',
    'operand': {
        'name': 'Interplanetary Cruise #%d' % uuid.uuid4(),
        # 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.
        'status': 'PAUSED',
        'advertisingChannelType': 'SEARCH',
        'biddingStrategyConfiguration': {
            'biddingStrategyType': 'MANUAL_CPC',
        },
        'budget': budget,
        # Required: Set the campaign's Dynamic Search Ad settings.
        'settings': [{
            'xsi_type': 'DynamicSearchAdsSetting',
            # Required: Set the domain name and language.
            'domainName': 'example.com',
            'languageCode': 'en'
        }],
        # Optional: Set the start date.
        'startDate': (datetime.datetime.now() +
                      datetime.timedelta(1)).strftime('%Y%m%d'),
        # Optional: Set the end date.
        'endDate': (datetime.datetime.now() +
                    datetime.timedelta(365)).strftime('%Y%m%d'),
    }
}]

campaign = campaign_service.mutate(operations)['value'][0]
campaign_id = campaign['id']

print 'Campaign with ID "%d" and name "%s" was added.' % (
    campaign_id, campaign['name'])

PHP

private static function createCampaign(AdWordsServices $adWordsServices,
    AdWordsSession $session, Budget $budget) {
  $campaignService = $adWordsServices->get($session, CampaignService::class);

  // Create campaign with some properties set.
  $campaign = new Campaign();
  $campaign->setName('Interplanetary Cruise #' . uniqid());
  $campaign->setAdvertisingChannelType(AdvertisingChannelType::SEARCH);

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

  $biddingStrategyConfiguration = new BiddingStrategyConfiguration();
  $biddingStrategyConfiguration->setBiddingStrategyType(
      BiddingStrategyType::MANUAL_CPC);
  $campaign->setBiddingStrategyConfiguration($biddingStrategyConfiguration);

  // Only the budgetId should be sent, all other fields will be ignored by
  // CampaignService.
  $campaignBudget = new Budget();
  $campaignBudget->setBudgetId($budget->getBudgetId());
  $campaign->setBudget($campaignBudget);

  // Required: Set the campaign's Dynamic Search Ads settings.
  $dynamicSearchAdsSetting = new DynamicSearchAdsSetting();
  // Required: Set the domain name and language.
  $dynamicSearchAdsSetting->setDomainName('example.com');
  $dynamicSearchAdsSetting->setLanguageCode('en');

  // Set the campaign settings.
  $campaign->setSettings([$dynamicSearchAdsSetting]);

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

  // Create a campaign operation.
  $operation = new CampaignOperation();
  $operation->setOperand($campaign);
  $operation->setOperator(Operator::ADD);

  // Create the campaign on the server and print out some information.
  $result = $campaignService->mutate([$operation]);
  $campaign = $result->getValue()[0];
  printf("Campaign with name '%s' and ID %d was added.\n",
      $campaign->getName(), $campaign->getId());

  return $campaign;
}

Perl

# Creates the campaign.
sub _create_campaign {
  my ($client, $budget) = @_;

  # Required: Set the campaign's Dynamic Search Ads settings.
  my $dynamic_search_ads_setting =
    Google::Ads::AdWords::v201705::DynamicSearchAdsSetting->new({
      # Required: Set the domain name and language.
      domainName   => "example.com",
      languageCode => "en"
    });

  # Calculating a start date of today and an end date 1 year from now.
  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 $campaign = Google::Ads::AdWords::v201705::Campaign->new({
      name => sprintf("Interplanetary Cruise #%s", uniqid()),
      biddingStrategyConfiguration =>
        Google::Ads::AdWords::v201705::BiddingStrategyConfiguration->new({
          biddingStrategyType => "MANUAL_CPC"
        }
        ),
      # Only the budgetId should be sent, all other fields will be ignored by
      # CampaignService.
      budget => Google::Ads::AdWords::v201705::Budget->new(
        {budgetId => $budget->get_budgetId()}
      ),
      advertisingChannelType => "SEARCH",
      settings               => [$dynamic_search_ads_setting],
      # 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"
    });

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

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

  # Display campaigns.
  my $new_campaign = $result->get_value()->[0];
  printf "Campaign with name '%s' and ID %d was added.\n",
    $new_campaign->get_name(),
    $new_campaign->get_id();
  return $new_campaign;
}

Ruby

def create_campaign(adwords, budget)
  campaign_srv = adwords.service(:CampaignService, API_VERSION)

  campaign = {
    :name => "Interplanetary Cruise #%d" % (Time.now.to_f * 1000).to_i,
    :advertising_channel_type => 'SEARCH',
    # 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.
    :status => 'PAUSED',
    :bidding_strategy_configuration => {
      :bidding_strategy_type => 'MANUAL_CPC'
    },
    # Only the budgetId should be sent; all other fields will be ignored by
    # CampaignService.
    :budget => {
      :budget_id => budget[:budget_id]
    },
    :settings => [
      :xsi_type => 'DynamicSearchAdsSetting',
      :domain_name => 'example.com',
      :language_code => 'en'
    ],
    # Optional: Set the start and end dates.
    :start_date => DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d'),
    :end_date => DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d')
  }

  operation = {
    :operand => campaign,
    :operator => 'ADD'
  }

  new_campaign = campaign_srv.mutate([operation])[:value].first
  puts "Campaign with name '%s' and ID %d was added." %
      [new_campaign[:name], new_campaign[:id]]

  return new_campaign
end

Dynamische Suchanzeigen in Kampagnen deaktivieren

Sie können dynamische Suchanzeigen auf Kampagnenebene deaktivieren, ohne die ganze Kampagne pausieren zu müssen. Hierzu müssen die Werte für DynamicSearchAdsSetting geändert und domainName auf "-" festgelegt werden. Außerdem muss weiterhin ein Sprachcode angegeben werden.

Anzeigengruppe erstellen

Mit Version 201705 der AdWords API wurde ein neuer Anzeigengruppentyp für dynamische Suchanzeigen eingeführt. Bei diesem Anzeigengruppentyp ist adGroupType auf AdGroupType.SEARCH_DYNAMIC_ADS festgelegt. Außerdem gelten die folgenden Einschränkungen:

  • Dieser Anzeigengruppentyp kann nur Suchnetzwerk-Kampagnen hinzugefügt werden.
  • Auf Kampagnenebene muss ein gültiges DynamicSearchAdsSetting-Objekt vorhanden sein, damit die Anzeigengruppe hinzugefügt werden kann. Sollte diese Einstellung nicht vorhanden sein, wird ein AdGroupServiceError.CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTING-Fehler ausgegeben.
  • In Anzeigengruppen dieses Typs sind keine einzuschließenden Keywords zulässig. Zielgruppen, dynamische Anzeigenziele und auszuschließende Keywords sind hingegen gestattet.
  • Wie bei allen Anzeigengruppen kann der adGroupType nicht nachträglich geändert werden.
  • In dieser Anzeigengruppe sind nur Anzeigenformate mit Bezug zu dynamischen Suchanzeigen zulässig.

Mit dem folgenden Codebeispiel wird eine SEARCH_DYNAMIC_ADS-Anzeigengruppe erstellt.

C#

private static AdGroup CreateAdGroup(AdWordsUser user, long campaignId) {
  // Get the AdGroupService.
  AdGroupService adGroupService =
      (AdGroupService) user.GetService(AdWordsService.v201705.AdGroupService);

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

  // Required: Set the ad group's type to Dynamic Search Ads.
  adGroup.adGroupType = AdGroupType.SEARCH_DYNAMIC_ADS;

  adGroup.name = string.Format("Earth to Mars Cruises #{0}",
    ExampleUtilities.GetRandomString());
  adGroup.campaignId = campaignId;
  adGroup.status = AdGroupStatus.PAUSED;

  // Recommended: Set a tracking URL template for your ad group if you want to use URL
  // tracking software.
  adGroup.trackingUrlTemplate = "http://tracker.example.com/traveltracker/{escapedlpurl}";

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

  CpcBid cpcBid = new CpcBid();
  cpcBid.bid = new Money();
  cpcBid.bid.microAmount = 3000000;

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

  adGroup.biddingStrategyConfiguration = biddingConfig;

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

  try {
    // Create the ad group.
    AdGroupReturnValue retVal = adGroupService.mutate(new AdGroupOperation[] { operation });

    // Display the results.
    AdGroup newAdGroup = retVal.value[0];
    Console.WriteLine("Ad group with id = '{0}' and name = '{1}' was created.",
      newAdGroup.id, newAdGroup.name);
    return newAdGroup;
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to create ad group.", e);
  }
}

Java

private static AdGroup createAdGroup(
    AdWordsServicesInterface adWordsServices, AdWordsSession session, Campaign campaign)
    throws ApiException, RemoteException {
  // Get the AdGroupService.
  AdGroupServiceInterface adGroupService =
      adWordsServices.get(session, AdGroupServiceInterface.class);

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

  // Required: Set the ad group's type to Dynamic Search Ads.
  adGroup.setAdGroupType(AdGroupType.SEARCH_DYNAMIC_ADS);

  adGroup.setName("Earth to Mars Cruises #" + System.currentTimeMillis());
  adGroup.setCampaignId(campaign.getId());
  adGroup.setStatus(AdGroupStatus.PAUSED);

  // Recommended: Set a tracking URL template for your ad group if you want to use URL
  // tracking software.
  adGroup.setTrackingUrlTemplate("http://tracker.example.com/traveltracker/{escapedlpurl}");

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

  CpcBid cpcBid = new CpcBid();
  cpcBid.setBid(new Money());
  cpcBid.getBid().setMicroAmount(3000000L);

  biddingConfig.setBids(new Bids[] {cpcBid});

  adGroup.setBiddingStrategyConfiguration(biddingConfig);

  // Create the operation.
  AdGroupOperation operation = new AdGroupOperation();
  operation.setOperand(adGroup);
  operation.setOperator(Operator.ADD);

  AdGroup newAdGroup = adGroupService.mutate(new AdGroupOperation[] {operation}).getValue(0);
  System.out.printf(
      "Ad group with name '%s' and ID %d was added.%n", newAdGroup.getName(), newAdGroup.getId());
  return newAdGroup;
}

Python

ad_group_service = client.GetService('AdGroupService')

operations = [{
    'operator': 'ADD',
    'operand': {
        'campaignId': campaign_id,
        'adGroupType': 'SEARCH_DYNAMIC_ADS',
        'name': 'Earth to Mars Cruises #%d' % uuid.uuid4(),
        'status': 'PAUSED',
        'biddingStrategyConfiguration': {
            'bids': [{
                'xsi_type': 'CpcBid',
                'bid': {
                    'microAmount': '3000000'
                },
            }]
        }
    }
}]

ad_group = ad_group_service.mutate(operations)['value'][0]
ad_group_id = ad_group['id']

print 'Ad group with ID "%d" and name "%s" was created.' % (
    ad_group_id, ad_group['name'])

PHP

private static function createAdGroup(
    AdWordsServices $adWordsServices,
    AdWordsSession $session,
    Campaign $campaign
) {
  $adGroupService = $adWordsServices->get($session, AdGroupService::class);

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

  // Required: Set the ad group's type to Dynamic Search Ads.
  $adGroup->setAdGroupType(AdGroupType::SEARCH_DYNAMIC_ADS);

  $adGroup->setName('Interplanetary Cruise #' . uniqid());
  $adGroup->setCampaignId($campaign->getId());
  $adGroup->setStatus(AdGroupStatus::PAUSED);

  // Recommended: Set a tracking URL template for your ad group if you want to
  // use URL tracking software.
  $adGroup->setTrackingUrlTemplate(
      'http://tracker.example.com/traveltracker/{escapedlpurl}');

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

  $cpcBid = new CpcBid();
  $money = new Money();
  $money->setMicroAmount(3000000);
  $cpcBid->setBid($money);
  $biddingStrategyConfiguration->setBids([$cpcBid]);

  $adGroup->setBiddingStrategyConfiguration($biddingStrategyConfiguration);

  // Create an ad group operation.
  $operation = new AdGroupOperation();
  $operation->setOperand($adGroup);
  $operation->setOperator(Operator::ADD);

  // Create the ad group on the server and print out some information.
  $result = $adGroupService->mutate([$operation]);
  $adGroup = $result->getValue()[0];
  printf("Ad group with name '%s' and ID %d was added.\n",
      $adGroup->getName(), $adGroup->getId());

  return $adGroup;
}

Perl

# Creates the ad group.
sub _create_ad_group {
  my ($client, $campaign) = @_;

  my $ad_group = Google::Ads::AdWords::v201705::AdGroup->new({
      name       => sprintf("Earth to Mars Cruises #%s", uniqid()),
      campaignId => $campaign->get_id(),
      # Required: Set the ad group's type to Dynamic Search Ads.
      adGroupType => "SEARCH_DYNAMIC_ADS",
      status      => "PAUSED",
      # Recommended: Set a tracking URL template for your ad group if you want
      # to use URL tracking software.
      trackingUrlTemplate =>
        "http://tracker.example.com/traveltracker/{escapedlpurl}",
      biddingStrategyConfiguration =>
        Google::Ads::AdWords::v201705::BiddingStrategyConfiguration->new({
          bids => [
            Google::Ads::AdWords::v201705::CpcBid->new({
                bid => Google::Ads::AdWords::v201705::Money->new(
                  {microAmount => 3000000}
                ),
              }
            ),
          ]})});

  # Create operation.
  my $ad_group_operation =
    Google::Ads::AdWords::v201705::AdGroupOperation->new({
      operator => "ADD",
      operand  => $ad_group
    });

  my $result =
    $client->AdGroupService()->mutate({operations => [$ad_group_operation]});
  my $new_ad_group = $result->get_value()->[0];
  printf "Ad group with name '%s' and ID %d was added.\n",
    $new_ad_group->get_name(), $new_ad_group->get_id();
  return $new_ad_group;
}

Ruby

def create_ad_group(adwords, campaign)
  ad_group_srv = adwords.service(:AdGroupService, API_VERSION)

  ad_group = {
    # Required: Set the ad group's tpe to Dynamic Search Ads.
    :ad_group_type => 'SEARCH_DYNAMIC_ADS',
    :name => "Earth to Mars Cruises #%d" % (Time.now.to_f * 1000).to_i,
    :campaign_id => campaign[:id],
    :status => 'PAUSED',
    # Recommended: Set a tracking URL template for your ad group if you want to
    # use URL tracking software.
    :tracking_url_template =>
        'http://tracker.example.com/traveltracker/{escapedlpurl}',
    :bidding_strategy_configuration => {
      :bids => [{
        :xsi_type => 'CpcBid',
        :bid => {
          :micro_amount => 3_000_000
        }
      }]
    }
  }

  operation = {
    :operand => ad_group,
    :operator => 'ADD'
  }

  new_ad_group = ad_group_srv.mutate([operation])[:value].first
  puts "Ad group with name '%s' and ID %d was added." %
      [new_ad_group[:name], new_ad_group[:id]]

  return new_ad_group
end

Dynamische Suchanzeige erstellen

Im nächsten Schritt erstellen Sie ein ExpandedDynamicSearchAd-Objekt. Bei dieser Anzeige werden der Titel, die angezeigte URL und die finale URL bei der Auslieferung automatisch generiert. Als Grundlage dienen dabei spezifische Informationen zum Domainnamen, die von DynamicSearchAdsSetting auf Kampagnenebene bereitgestellt werden. Die Beschreibung der Anzeige (description) müssen Sie selbst angeben.

C#

private static ExpandedDynamicSearchAd CreateExpandedDSA(AdWordsUser user, long adGroupId) {
  // Get the AdGroupAdService.
  AdGroupAdService service =
    (AdGroupAdService) user.GetService(AdWordsService.v201705.AdGroupAdService);

  // Create an Expanded Dynamic Search Ad. This ad will have its headline, display URL and
  // final URL auto-generated at serving time according to domain name specific information
  // provided by DynamicSearchAdsSetting at the campaign level.
  ExpandedDynamicSearchAd expandedDSA = new ExpandedDynamicSearchAd();
  // Set the ad description.
  expandedDSA.description = "Buy your tickets now!";

  // Create the ad group ad.
  AdGroupAd adGroupAd = new AdGroupAd();
  adGroupAd.adGroupId = adGroupId;
  adGroupAd.ad = expandedDSA;

  // Optional: Set the status.
  adGroupAd.status = AdGroupAdStatus.PAUSED;

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

  try {
    // Create the ad.
    AdGroupAdReturnValue retval = service.mutate(new AdGroupAdOperation[] { operation });

    // Display the results.
    AdGroupAd newAdGroupAd = retval.value[0];
    ExpandedDynamicSearchAd newAd = newAdGroupAd.ad as ExpandedDynamicSearchAd;
    Console.WriteLine("Expanded Dynamic Search Ad with ID '{0}' and description '{1}' " +
        "was added.", newAd.id, newAd.description);
    return newAd;
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to create Expanded Dynamic Search Ad.", e);
  }
}

Java

private static void createExpandedDSA(
    AdWordsServicesInterface adWordsServices, AdWordsSession session, AdGroup adGroup)
    throws ApiException, RemoteException {
  // Get the AdGroupAdService.
  AdGroupAdServiceInterface adGroupAdService =
      adWordsServices.get(session, AdGroupAdServiceInterface.class);

  // Create the expanded Dynamic Search Ad. This ad will have its headline and final URL
  // auto-generated at serving time according to domain name specific information provided
  // by DynamicSearchAdsSetting at the campaign level.
  ExpandedDynamicSearchAd expandedDSA = new ExpandedDynamicSearchAd();
  // Set the ad description.
  expandedDSA.setDescription("Buy your tickets now!");

  // Create the ad group ad.
  AdGroupAd adGroupAd = new AdGroupAd();
  adGroupAd.setAdGroupId(adGroup.getId());
  adGroupAd.setAd(expandedDSA);

  // Optional: Set the status.
  adGroupAd.setStatus(AdGroupAdStatus.PAUSED);

  // Create the operation.
  AdGroupAdOperation operation = new AdGroupAdOperation();
  operation.setOperator(Operator.ADD);
  operation.setOperand(adGroupAd);

  // Create the ad.
  AdGroupAd newAdGroupAd =
      adGroupAdService.mutate(new AdGroupAdOperation[] {operation}).getValue(0);
  ExpandedDynamicSearchAd newExpandedDSA = (ExpandedDynamicSearchAd) newAdGroupAd.getAd();
  System.out.printf(
      "Expanded Dynamic Search Ad with ID %d and description '%s' was added.%n",
      newExpandedDSA.getId(), newExpandedDSA.getDescription());
}

Python

# Get the AdGroupAdService.
ad_group_ad_service = client.GetService('AdGroupAdService')

# Create the operation
operations = [{
    'operator': 'ADD',
    'operand': {
        'xsi_type': 'AdGroupAd',
        'adGroupId': ad_group_id,
        # Create the expanded dynamic search ad. This ad will have its
        # headline and final URL auto-generated at serving time according to
        # domain name specific information provided by DynamicSearchAdsSetting
        # at the campaign level.
        'ad': {
            'xsi_type': 'ExpandedDynamicSearchAd',
            # Set the ad description.
            'description': 'Buy your tickets now!'
        },
        # Optional: Set the status.
        'status': 'PAUSED',
    }
}]

# Create the ad.
ad = ad_group_ad_service.mutate(operations)['value'][0]['ad']

# Display the results.
print ('Expanded dynamic search ad with ID "%d" and description "%s" was '
       'added' % (ad['id'], ad['description']))

PHP

private static function createExpandedDSA(
    AdWordsServices $adWordsServices,
    AdWordsSession $session,
    AdGroup $adGroup
) {
  $adGroupAdService
      = $adWordsServices->get($session, AdGroupAdService::class);

  // Create the expanded Dynamic Search Ad. This ad will have its headline
  // and final URL auto-generated at serving time according to domain name
  // specific information provided by DynamicSearchAdsSetting at the
  // campaign level.
  $expandedDSA = new ExpandedDynamicSearchAd();
  // Set the ad description.
  $expandedDSA->setDescription('Buy your tickets now!');

  // Create the ad group ad.
  $adGroupAd = new AdGroupAd();
  $adGroupAd->setAdGroupId($adGroup->getId());
  $adGroupAd->setAd($expandedDSA);

  // Optional: Set the status.
  $adGroupAd->setStatus(AdGroupAdStatus::PAUSED);

  // Create the operation.
  $operation = new AdGroupAdOperation();
  $operation->setOperator(Operator::ADD);
  $operation->setOperand($adGroupAd);

  // Create the ad on the server and print some information.
  $result = $adGroupAdService->mutate([$operation]);
  $newAdGroupAd = $result->getValue()[0];
  $expandedDSA = $newAdGroupAd->getAd();
  printf(
      "Expanded Dynamic Search Ad with ID %d and description '%s' was"
          . " added.\n",
      $expandedDSA->getId(),
      $expandedDSA->getDescription()
  );
}

Perl

# Creates the expanded Dynamic Search Ad.
sub _create_expanded_DSA {
  my ($client, $ad_group) = @_;
  # Create the expanded Dynamic Search Ad. This ad will have its headline and
  # final URL auto-generated at serving time according to domain name specific
  # information provided by DynamicSearchAdsSetting at the campaign level.
  my $expanded_DSA =
    Google::Ads::AdWords::v201705::ExpandedDynamicSearchAd->new({
      # Set the ad description.
      description => "Buy your tickets now!",
    });

  # Create the ad group ad.
  my $ad_group_ad = Google::Ads::AdWords::v201705::AdGroupAd->new({
    adGroupId => $ad_group->get_id(),
    ad        => $expanded_DSA,
    # Optional: Set the status.
    status => "PAUSED"
  });

  # Create operation.
  my $operation = Google::Ads::AdWords::v201705::AdGroupAdOperation->new({
    operator => "ADD",
    operand  => $ad_group_ad
  });

  my $result =
    $client->AdGroupAdService()->mutate({operations => [$operation]});
  my $new_ad_group_ad = $result->get_value()->[0];
  my $new_expanded_dsa = $new_ad_group_ad->get_ad();
  printf
    "Expanded Dynamic Search Ad with ID %d and description '%s' was added.\n",
    $new_expanded_dsa->get_id(), $new_expanded_dsa->get_description();
}

Ruby

def create_expanded_dsa(adwords, ad_group)
  ad_group_ad_srv = adwords.service(:AdGroupAdService, API_VERSION)

  # Create the expanded Dynamic Search Ad. This ad will have its headline and
  # final URL auto-generated at serving time according to domain name specific
  # information provided by DynamicSearchAdsSetting at the campaign level.
  expanded_dsa = {
    :xsi_type => 'ExpandedDynamicSearchAd',
    :description => 'Buy your tickets now!'
  }

  ad_group_ad = {
    :ad_group_id => ad_group[:id],
    :ad => expanded_dsa,
    # Optional: Set the status.
    :status => 'PAUSED'
  }

  operation = {
    :operand => ad_group_ad,
    :operator => 'ADD'
  }

  new_ad_group_ad = ad_group_ad_srv.mutate([operation])[:value].first
  new_expanded_dsa = new_ad_group_ad[:ad]
  puts "Expanded Dynamic Search Ad with ID %d and description '%s' was added." %
      [new_expanded_dsa[:id], new_expanded_dsa[:description]]
end

In dynamischen Suchanzeigen wird das Feld finalUrls vom AdWords-System berechnet, wenn die Anzeige generiert wird. Sie können dieses Feld daher nicht festlegen, wenn Sie dynamische Suchanzeigen erstellen. Wenn Sie URL-Tracking-Software verwenden möchten, können Sie mit dem Feld trackingUrlTemplate angeben, welche zusätzlichen Tracking-Parameter oder Weiterleitungen erforderlich sind. Beim Festlegen dieses Feldes müssen Sie einen der folgenden Parameter einschließen, damit vom AdWords-System die resultierende übereinstimmende finale URL eingefügt werden kann:

Parameter Erklärung
{unescapedlpurl}

Nicht umschriebene Zielseiten-URL. Wenn Sie etwas am Ende hinzufügen möchten. Beispiel:

{unescapedlpurl}?dsa=true

{escapedlpurl}

Umschriebene (URL-codierte) Zielseiten-URL. Wenn Sie zu einem Tracker umleiten möchten. Beispiel:

http://tracking.com/lp={escapedurl}

{lpurlpath}

Nur Pfad und Abfrageparameter aus der berechneten URL. Beispiel:

http://tracking.com.com/track/{lpurlpath}

{lpurl}

Codiert ? und = der Zielseiten-URL. Endet mit Suchanfrage. Wenn "{lpurl}" ganz am Anfang des Feldes trackingUrlTemplate steht, wird der Parameter durch den Wert von {unescapedurl} ersetzt. Beispiel:

http://tracking.com/redir.php?tracking=xyz&url={lpurl}

Beispiel:

dsa.setTrackingUrlTemplate("http://example.org/traveltracker/{escapedlpurl}");

Kriterien für dynamische Suchanzeigen angeben

Zum Abschluss sollten Sie noch Kriterien angeben, um die Auslieferung der dynamischen Suchanzeigen auszulösen. Dies erfolgt über das Webpage-Kriteriumsobjekt.

Dazu fügen Sie dem Webpage-Kriterium ein WebpageParameter-Objekt hinzu, das ein bis drei WebpageConditions enthält. Mit diesen Objekten können Sie genau angeben, was in der Domain gefiltert oder gesucht werden soll, die zuvor in den Kampagneneinstellungen angegeben wurde.

Innerhalb einer Domain kann nach vier Elementen gefiltert werden:

WebPageConditionOperand Beschreibung
URL String, der mit einer Teil-URL einer Seite übereinstimmt
CATEGORY String mit einer Kategorie, die genau mit der Kategorie der Seite übereinstimmen muss
PAGE_TITLE String, der mit einem Teil des Seitentitels übereinstimmt
PAGE_CONTENT String, der mit einem Teil der Inhalte auf einer bestimmten indexierten Seite übereinstimmt
CUSTOM_LABEL String, der mit der Ausrichtungsbedingung für das benutzerdefinierte Label einer Website übereinstimmt.

Im folgenden Beispiel wird eine Webseitenbedingung erstellt, mit der nach Text im Zweig /children der Mars-Ferienwebsite gesucht wird, jedoch nur auf Seiten mit "Special Offer" im Titel:

Kategorien Ihrer Website ermitteln

Mit DataService können Sie eine Liste von Kategorien abrufen, von denen Google annimmt, dass sie auf Ihre Website zutreffen. Sie können nach Domains oder Kampagnen filtern. Im folgenden Beispiel wird mithilfe des Codes die Liste der Kategorien einer Website innerhalb einer bestimmten Kampagne abgerufen:

DataServiceInterface dataService =
  adWordsServices.get(session, DataServiceInterface.class);

// Create selector.
SelectorBuilder builder = new SelectorBuilder();
Selector selector = builder
    .fields("DomainName", "Category", "IsoLanguage")
    .equals("DomainName", "example.org")
    .equals("CampaignId", campaignId)
    .limit(PAGE_SIZE)
    .build();

DomainCategoryPage page = dataService.getDomainCategory(selector);

Teile Ihrer Website ausschließen

Mit AdGroupCriterionService können Sie auch ausschließende Webpage-Kriterien einrichten. So könnten Sie beispielsweise Seiten mit einem bestimmten Titel ausschließen, die Sie über eine andere Kampagne oder Anzeigengruppe verwalten möchten.

Weitere Kriterien

Kampagnen und Anzeigengruppen mit dynamischen Suchanzeigen sind nicht auf Webpage-Kriterien beschränkt. Sie können weiterhin andere Kriterientypen verwenden, um die Qualität Ihrer Anzeigen zu optimieren. Sie sollten jedoch nicht zu viele zusätzliche Kriterien verwenden, da sonst die Effizienz der automatischen Ausrichtung über dynamische Suchanzeigen beeinträchtigt werden kann.

Seitenfeeds für dynamische Suchanzeigen

Dynamische Suchanzeigen sind standardmäßig auf komplette Websites oder Teile davon ausgerichtet, sodass der Schwerpunkt nicht auf bestimmten Seiten-URLs liegt. Falls Sie die Ausrichtung auf URLs genauer steuern möchten, können Sie mithilfe von Seitenfeeds für dynamische Suchanzeigen genau festlegen, welche URLs mit diesen Anzeigen verwendet werden. Wenn Sie einen Seitenfeed mit Ihren Produkten und den zugehörigen Zielseiten bereitstellen, kann das AdWords-System einfacher bestimmen, wann Ihre Anzeigen ausgeliefert werden und auf welche Seite Ihrer Website die Nutzer weitergeleitet werden.

So richten Sie einen Seitenfeed für dynamische Suchanzeigen ein:

  1. Erstellen Sie einen Feed und fügen Sie diesem Seiten-URLs zu.
  2. Richten Sie die Kampagne so ein, dass der Seitenfeed für dynamische Suchanzeigen verwendet wird.
  3. Empfohlen: Fügen Sie den URLs in Ihrem Seitenfeed benutzerdefinierte Labels hinzu, um die Ziele für Ihre dynamischen Suchanzeigen zu kategorisieren und zu organisieren.

Seitenfeed erstellen

Wenn Sie Seitenfeeds für dynamische Suchanzeigen verwenden möchten, müssen Sie zuerst einen Feed mit criterionType = 61 erstellen. Hierzu können Sie der Anleitung im Leitfaden zu Feeddiensten folgen – abgesehen von zwei Unterschieden:

  1. Sie müssen lediglich einen Feed erstellen, die Artikel hinzufügen und den Feed den Feldern für Seitenfeed-Platzhalter zuordnen.
  2. In Seitenfeeds für dynamische Suchanzeigen wird statt des Felds placeholderType das Feld criterionType verwendet.

Funktionierenden Beispielcode finden Sie im entsprechenden Abschnitt.

Kampagne für Seitenfeeds einrichten

Sie können eine Kampagne mit dynamischen Suchanzeigen für die Verwendung von Seitenfeeds einrichten, indem Sie die pagefeed-Property für die DynamicSearchAdSetting festlegen.

Der erste Schritt hierfür ist, die DynamicSearchAdSetting Ihrer Kampagne mit dynamischen Suchanzeigen abzurufen.

C#

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

Selector selector = new Selector() {
  fields = new string[] { Campaign.Fields.Id, Campaign.Fields.Settings },
  predicates = new Predicate[]{
    Predicate.Equals(Campaign.Fields.Id, campaignId)
  },
  paging = Paging.Default
};

CampaignPage page = campaignService.get(selector);

if (page == null || page.entries == null || page.entries.Length == 0) {
  throw new System.ApplicationException(string.Format(
      "Failed to retrieve campaign with ID = {0}.", campaignId));
}
Campaign campaign = page.entries[0];

if (campaign.settings == null) {
  throw new System.ApplicationException("This is not a DSA campaign.");
}

DynamicSearchAdsSetting dsaSetting = null;
Setting[] campaignSettings = campaign.settings;

for (int i = 0; i < campaign.settings.Length; i++) {
  Setting setting = campaignSettings[i];
  if (setting is DynamicSearchAdsSetting) {
    dsaSetting = (DynamicSearchAdsSetting) setting;
    break;
  }
}

if (dsaSetting == null) {
  throw new System.ApplicationException("This is not a DSA campaign.");
}

Java

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

Selector selector =
    new SelectorBuilder()
        .fields(CampaignField.Id, CampaignField.Settings)
        .equalsId(campaignId)
        .build();

CampaignPage campaignPage = campaignService.get(selector);
if (campaignPage.getEntries() == null || campaignPage.getTotalNumEntries() == 0) {
  throw new IllegalArgumentException("No campaign found with ID: " + campaignId);
}
Campaign campaign = campaignPage.getEntries(0);

if (campaign.getSettings() == null) {
  throw new IllegalArgumentException(
      "Campaign with ID " + campaignId + " is not a DSA campaign.");
}

DynamicSearchAdsSetting dsaSetting = null;
for (Setting setting : campaign.getSettings()) {
  if (setting instanceof DynamicSearchAdsSetting) {
    dsaSetting = (DynamicSearchAdsSetting) setting;
    break;
  }
}

if (dsaSetting == null) {
  throw new IllegalArgumentException(
      "Campaign with ID " + campaignId + " is not a DSA campaign.");
}

Python

# Get the CampaignService.
campaign_service = client.GetService('CampaignService', version='v201705')

selector = {
    'fields': ['Id', 'Settings'],
    'predicates': [{
        'field': 'Id',
        'operator': 'EQUALS',
        'values': [campaign_id]
    }]
}

response = campaign_service.get(selector)

if response['totalNumEntries']:
  campaign = response['entries'][0]
else:
  raise ValueError('No campaign with ID "%d" exists.' % campaign_id)

if not campaign['settings']:
  raise ValueError('This is not a DSA campaign.')

dsa_setting = None

campaign_settings = campaign['settings']

for setting in campaign_settings:
  if setting['Setting.Type'] == 'DynamicSearchAdsSetting':
    dsa_setting = setting
    break

if dsa_setting is None:
  raise ValueError('This is not a DSA campaign.')
    

PHP

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

// Create selector.
$selector = new Selector();
$selector->setFields(['Id', 'Settings']);
$selector->setPredicates(
    [new Predicate('CampaignId', PredicateOperator::IN, [$campaignId])]);

$result = $campaignService->get($selector);
if (empty($result->getEntries()) || $result->getTotalNumEntries() === 0) {
  throw new InvalidArgumentException(
      'No campaign found with ID: ' . $campaignId);
}
$campaign = $result->getEntries()[0];

if ($campaign->getSettings() === null) {
  throw new InvalidArgumentException(
      'Campaign with ID ' . $campaignId . ' is not a DSA campaign.');
}

$dsaSetting = null;
foreach ($campaign->getSettings() as $setting) {
  if ($setting instanceof DynamicSearchAdsSetting) {
    $dsaSetting = $setting;
    break;
  }
}

if ($dsaSetting === null) {
  throw new InvalidArgumentException(
      'Campaign with ID ' . $campaignId . ' is not a DSA campaign.');
}
    

Perl

my $paging = Google::Ads::AdWords::v201705::Paging->new({
  startIndex    => 0,
  numberResults => PAGE_SIZE
});
my $selector = Google::Ads::AdWords::v201705::Selector->new({
    fields     => ["Id", "Settings"],
    predicates => [
      Google::Ads::AdWords::v201705::Predicate->new({
          field    => "CampaignId",
          operator => "EQUALS",
          values   => [$campaign_id]})
    ],
    paging => $paging
  });

my $dsa_setting = undef;
Google::Ads::AdWords::Utilities::PageProcessor->new({
    client   => $client,
    service  => $client->CampaignService(),
    selector => $selector
  }
  )->process_entries(
  sub {
    my ($campaign) = @_;
    if ($campaign->get_settings()) {
      foreach my $setting (@{$campaign->get_settings()}) {
        if (
          $setting->isa(
            "Google::Ads::AdWords::v201705::DynamicSearchAdsSetting"))
        {
          $dsa_setting = $setting;
          last;
        }
      }
    }
  });

if (!$dsa_setting) {
  die sprintf("Campaign with ID %s is not a DSA campaign.", $campaign_id);
}
    

Ruby

campaign_srv = adwords.service(:CampaignService, API_VERSION)

selector = {
  :fields => ['Id', 'Settings'],
  :predicates => [
    {:field => 'CampaignId', :operator => 'IN', :values => [campaign_id]}
  ]
}

campaign_page = campaign_srv.get(selector)
if campaign_page.nil? or campaign_page[:entries].nil? or
    campaign_page[:total_num_entries] == 0
  raise 'No campaign found with ID: %d' % campaign_id
end

campaign = campaign_page[:entries].first

if campaign[:settings].nil?
  raise 'Campaign with ID %d is not a DSA campaign.' % campaign_id
end

dsa_setting = nil
campaign[:settings].each do |setting|
  if setting[:setting_type] == 'DynamicSearchAdsSetting'
    dsa_setting = setting
    break
  end
end

if dsa_setting.nil?
  raise 'Campaign with ID %d is not a DSA campaign.' % campaign_id
end
    

Nun legen Sie die Seitenfeeds fest, indem Sie die feedIds in der pageFeed-Property der DynamicSearchAdsSetting Ihrer Kampagne festlegen. Dabei haben Sie die Möglichkeit, über das Feld useSuppliedUrlsOnly anzugeben, ob nur die angegebenen URLs für Ihre dynamischen Suchanzeigen verwendet werden sollen.

C#

// Use a page feed to specify precisely which URLs to use with your
// Dynamic Search Ads.
dsaSetting.pageFeed = new PageFeed() {
  feedIds = new long[] {
    feedId
  },
};

// Optional: Specify whether only the supplied URLs should be used with your
// Dynamic Search Ads.
dsaSetting.useSuppliedUrlsOnly = true;

Campaign campaignToUpdate = new Campaign();
campaignToUpdate.id = campaignId;
campaignToUpdate.settings = campaignSettings;

CampaignOperation operation = new CampaignOperation();
operation.operand = campaignToUpdate;
operation.@operator = Operator.SET;

try {
  CampaignReturnValue retval = campaignService.mutate(new CampaignOperation[] { operation });
  Campaign updatedCampaign = retval.value[0];
  Console.WriteLine("DSA page feed for campaign ID '{0}' was updated with feed ID '{1}'.",
      updatedCampaign.id, feedId);
} catch (Exception e) {
  throw new System.ApplicationException("Failed to set page feed for campaign.", e);
}

Java

// Use a page feed to specify precisely which URLs to use with your
// Dynamic Search Ads.
PageFeed pageFeed = new PageFeed();
pageFeed.setFeedIds(new long[] {feedDetails.feedId});
dsaSetting.setPageFeed(pageFeed);

// Optional: Specify whether only the supplied URLs should be used with your
// Dynamic Search Ads.
dsaSetting.setUseSuppliedUrlsOnly(true);

Campaign updatedCampaign = new Campaign();
updatedCampaign.setId(campaignId);
updatedCampaign.setSettings(campaign.getSettings());

CampaignOperation operation = new CampaignOperation();
operation.setOperand(updatedCampaign);
operation.setOperator(Operator.SET);

updatedCampaign = campaignService.mutate(new CampaignOperation[] {operation}).getValue(0);
System.out.printf(
    "DSA page feed for campaign ID %d was updated with feed ID %d.%n",
    updatedCampaign.getId(), feedDetails.feedId);

Python

dsa_setting['pageFeed'] = {
    'feedIds': [feed_id]
}

# Optional: Specify whether only the supplied URLs should be used with your
# Dynamic Search Ads.
dsa_setting['useSuppliedUrlsOnly'] = True

operation = {
    'operand': {
        'id': campaign_id,
        'settings': campaign_settings
    },
    'operator': 'SET'
}

campaign_service.mutate([operation])
print 'DSA page feed for campaign ID "%d" was updated with feed ID "%d".' % (
    campaign_id, feed_id)

PHP

// Use a page feed to specify precisely which URLs to use with your
// Dynamic Search Ads.
$pageFeed = new PageFeed();
$pageFeed->setFeedIds([$feedDetails->feedId]);
$dsaSetting->setPageFeed($pageFeed);

// Optional: Specify whether only the supplied URLs should be used with your
// Dynamic Search Ads.
$dsaSetting->setUseSuppliedUrlsOnly(true);

$updatedCampaign = new Campaign();
$updatedCampaign->setId($campaignId);
$updatedCampaign->setSettings($campaign->getSettings());

$operation = new CampaignOperation();
$operation->setOperand($updatedCampaign);
$operation->setOperator(Operator::SET);

// Update the campaign on the server and print out some information.
$result = $campaignService->mutate([$operation]);
$updatedCampaign = $result->getValue()[0];
printf("DSA page feed for campaign ID %d was updated with feed ID %d.\n",
    $updatedCampaign->getId(), $feedDetails->feedId);

Perl

# Use a page feed to specify precisely which URLs to use with your
# Dynamic Search Ads.
my $page_feed = Google::Ads::AdWords::v201705::PageFeed->new({
    feedIds => [$feed_details->{"feedId"}]});
$dsa_setting->set_pageFeed($page_feed);

# Optional: Specify whether only the supplied URLs should be used with your
# Dynamic Search Ads.
$dsa_setting->set_useSuppliedUrlsOnly(1);

my $updated_campaign = Google::Ads::AdWords::v201705::Campaign->new({
    id       => $campaign_id,
    settings => [$dsa_setting]});

my $operation = Google::Ads::AdWords::v201705::CampaignOperation->new({
  operand  => $updated_campaign,
  operator => "SET"
});

$client->CampaignService()->mutate({operations => [$operation]});
printf(
  "DSA page feed for campaign ID %d was updated with feed ID %d.\n",
  $updated_campaign->get_id(),
  $feed_details->{"feedId"});

Ruby

# Use a page feed to specify precisely which URLs to use with your Dynamic
# Search Ads.
page_feed = {
  :feed_ids => [feed_details[:feed_id]]
}
dsa_setting[:page_feed] = page_feed

# Optional: Specify whether only the supplied URLs should be used with your
# Dynamic Search Ads.
dsa_setting[:use_supplied_urls_only] = true

updated_campaign = {
  :id => campaign_id,
  :settings => campaign[:settings]
}

operation = {
  :operand => updated_campaign,
  :operator => 'SET'
}

updated_campaign = campaign_srv.mutate([operation])[:value].first
puts "DSA page feed for campaign ID %d was updated with feed ID %d." % [
  updated_campaign[:id], feed_details[:feed_id]
]

Hier sehen Sie, wie die einzelnen Einstellungen auf der AdWords-Benutzeroberfläche benannt sind.

useSuppliedUrlsOnly pageFeed.feedIds Einstellung auf der AdWords-Benutzeroberfläche
false Nicht zutreffend Den Google-Index meiner Website verwenden
false Es ist mindestens eine Feed-ID angegeben. URLs aus dem Google-Index meiner Website und aus meinem Seitenfeed verwenden
true Es ist mindestens eine Feed-ID angegeben. Nur URLs aus meinem Seitenfeed verwenden
true Leer oder null Wird nicht unterstützt. Die API gibt den Fehler SettingError.DYNAMIC_SEARCH_ADS_SETTING_AT_LEAST_ONE_FEED_ID_MUST_BE_PRESENT aus.

Anzeigen mithilfe von benutzerdefinierten Labels auf Seitenfeed-URLs ausrichten

Sie können benutzerdefinierte Labels verwenden, um Anzeigen auf URLs im Seitenfeed auszurichten und Gebote für diese URLs festzulegen. Hierzu erstellen Sie ein Webpage-Kriterium, bei dem CUSTOM_LABEL zum Filtern auf operand festgelegt ist.

C#

private static BiddableAdGroupCriterion AddDsaTargeting(AdWordsUser user, long adGroupId,
    string labelName) {
  // Get the AdGroupCriterionService.
  AdGroupCriterionService adGroupCriterionService =
    (AdGroupCriterionService) user.GetService(AdWordsService.v201705.AdGroupCriterionService);

  // Create a webpage criterion.
  Webpage webpage = new Webpage();

  WebpageParameter parameter = new WebpageParameter();
  parameter.criterionName = "Test criterion";
  webpage.parameter = parameter;

  // Add a condition for label=specified_label_name.
  WebpageCondition condition = new WebpageCondition();
  condition.operand = WebpageConditionOperand.CUSTOM_LABEL;
  condition.argument = labelName;
  parameter.conditions = new WebpageCondition[] { condition };

  BiddableAdGroupCriterion criterion = new BiddableAdGroupCriterion();
  criterion.adGroupId = adGroupId;
  criterion.criterion = webpage;

  // Set a custom bid for this criterion.
  BiddingStrategyConfiguration biddingStrategyConfiguration =
      new BiddingStrategyConfiguration();

  biddingStrategyConfiguration.bids = new Bids[] {
    new CpcBid() {
      bid = new Money() {
        microAmount = 1500000
      }
    }
  };

  criterion.biddingStrategyConfiguration = biddingStrategyConfiguration;

  AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
  operation.operand = criterion;
  operation.@operator = Operator.ADD;

  try {
    AdGroupCriterionReturnValue retval = adGroupCriterionService.mutate(
        new AdGroupCriterionOperation[] { operation });
    BiddableAdGroupCriterion newCriterion = (BiddableAdGroupCriterion) retval.value[0];

    Console.WriteLine("Web page criterion with ID = {0} and status = {1} was created.",
      newCriterion.criterion.id, newCriterion.userStatus);

    return newCriterion;
  } catch (Exception e) {
    throw new System.ApplicationException("Failed to create webpage criterion for " +
        "custom page feed label.", e);
  }
}
    

Java

private static void addDsaTargeting(
    AdWordsServicesInterface adWordsServices,
    AdWordsSession session,
    Long adGroupId,
    String dsaPageUrlLabel)
    throws ApiException, RemoteException {
  // Get the AdGroupCriterionService.
  AdGroupCriterionServiceInterface adGroupCriterionService =
      adWordsServices.get(session, AdGroupCriterionServiceInterface.class);

  // Create a webpage criterion.
  Webpage webpage = new Webpage();

  WebpageParameter parameter = new WebpageParameter();
  parameter.setCriterionName("Test criterion");
  webpage.setParameter(parameter);

  // Add a condition for label=specified_label_name.
  WebpageCondition condition = new WebpageCondition();
  condition.setOperand(WebpageConditionOperand.CUSTOM_LABEL);
  condition.setArgument(dsaPageUrlLabel);
  parameter.setConditions(new WebpageCondition[] {condition});

  BiddableAdGroupCriterion criterion = new BiddableAdGroupCriterion();
  criterion.setAdGroupId(adGroupId);
  criterion.setCriterion(webpage);

  // Set a custom bid for this criterion.
  BiddingStrategyConfiguration biddingStrategyConfiguration = new BiddingStrategyConfiguration();

  CpcBid cpcBid = new CpcBid();
  Money money = new Money();
  money.setMicroAmount(1_500_000L);
  cpcBid.setBid(money);
  biddingStrategyConfiguration.setBids(new Bids[] {cpcBid});

  criterion.setBiddingStrategyConfiguration(biddingStrategyConfiguration);

  AdGroupCriterionOperation operation = new AdGroupCriterionOperation();
  operation.setOperand(criterion);
  operation.setOperator(Operator.ADD);

  BiddableAdGroupCriterion newCriterion =
      (BiddableAdGroupCriterion)
          adGroupCriterionService.mutate(new AdGroupCriterionOperation[] {operation}).getValue(0);
  System.out.printf(
      "Web page criterion with ID %d and status '%s' was created.%n",
      newCriterion.getCriterion().getId(), newCriterion.getUserStatus());
}
    

Python

# Get the AdGroupCriterionService.
ad_group_criterion_service = client.GetService('AdGroupCriterionService',
                                               version='v201705')

# Create the operation.
operation = {
    'operand': {
        'xsi_type': 'BiddableAdGroupCriterion',
        'adGroupId': ad_group_id,
        # Create a webpage criterion.
        'criterion': {
            'xsi_type': 'Webpage',
            'parameter': {
                'criterionName': 'Test criterion',
                # Add a condition for label=specified_label_name.
                'conditions': [{
                    'operand': 'CUSTOM_LABEL',
                    'argument': label_name
                }],
            }
        },
        # Set a custom bid for this criterion
        'biddingStrategyConfiguration': {
            'bids': [{
                'xsi_type': 'CpcBid',
                'bid': {
                    'microAmount': 1500000
                }
            }]
        }
    },
    'operator': 'ADD'
}

criterion = ad_group_criterion_service.mutate([operation])['value'][0]
print 'Web page criterion with ID "%d" and status "%s" was created.' % (
    criterion['criterion']['id'], criterion['userStatus'])
return criterion
    

PHP

private static function addDsaTargeting(
    AdWordsServices $adWordsServices,
    AdWordsSession $session,
    $adGroupId,
    $dsaPageUrlLabel
) {
  $adGroupCriterionService =
      $adWordsServices->get($session, AdGroupCriterionService::class);

  // Create a webpage criterion.
  $webpage = new Webpage();

  $parameter = new WebpageParameter();
  $parameter->setCriterionName('Test criterion');
  $webpage->setParameter($parameter);

  // Add a condition for label=specified_label_name.
  $condition = new WebpageCondition();
  $condition->setOperand(WebpageConditionOperand::CUSTOM_LABEL);
  $condition->setArgument($dsaPageUrlLabel);
  $parameter->setConditions([$condition]);

  $criterion = new BiddableAdGroupCriterion();
  $criterion->setAdGroupId($adGroupId);
  $criterion->setCriterion($webpage);

  // Set a custom bid for this criterion.
  $biddingStrategyConfiguration = new BiddingStrategyConfiguration();

  $cpcBid = new CpcBid();
  $money = new Money();
  $money->setMicroAmount(1500000);
  $cpcBid->setBid($money);
  $biddingStrategyConfiguration->setBids([$cpcBid]);

  $criterion->setBiddingStrategyConfiguration($biddingStrategyConfiguration);

  $operation = new AdGroupCriterionOperation();
  $operation->setOperand($criterion);
  $operation->setOperator(Operator::ADD);

  // Create ad group criterion on the server and print out some information.
  $result = $adGroupCriterionService->mutate([$operation]);
  $criterion = $result->getValue()[0];
  printf("Web page criterion with ID %d and status '%s' was created.\n",
      $criterion->getCriterion()->getId(), $criterion->getUserStatus());
}
    

Perl

sub _add_dsa_targeting {
  my ($client, $ad_group_id, $dsa_page_url_label) = @_;

  # Create a webpage criterion.
  # Add a condition for label=specified_label_name.
  my $condition = Google::Ads::AdWords::v201705::WebpageCondition->new({
    operand  => "CUSTOM_LABEL",
    argument => $dsa_page_url_label
  });

  # Create a webpage criterion for special offers.
  my $parameter = Google::Ads::AdWords::v201705::WebpageParameter->new({
      criterionName => "Test criterion",
      conditions    => [$condition]});

  my $webpage = Google::Ads::AdWords::v201705::Webpage->new({
    parameter => $parameter
  });

  # Create biddable ad group criterion.
  my $biddable_ad_group_criterion =
    Google::Ads::AdWords::v201705::BiddableAdGroupCriterion->new({
      adGroupId => $ad_group_id,
      criterion => $webpage,
      # Set a custom bid for this criterion.
      biddingStrategyConfiguration =>
        Google::Ads::AdWords::v201705::BiddingStrategyConfiguration->new({
          bids => [
            Google::Ads::AdWords::v201705::CpcBid->new({
                bid => Google::Ads::AdWords::v201705::Money->new(
                  {microAmount => 1500000}
                ),
              }
            ),
          ]})});

  # Create operation.
  my $operation =
    Google::Ads::AdWords::v201705::AdGroupCriterionOperation->new({
      operator => "ADD",
      operand  => $biddable_ad_group_criterion
    });

  # Create the criterion.
  my $result =
    $client->AdGroupCriterionService()->mutate({operations => [$operation]});
  my $new_ad_group_criterion = $result->get_value()->[0];
  printf "Web page criterion with ID %d and status '%s' was created.\n",
    $new_ad_group_criterion->get_criterion()->get_id(),
    $new_ad_group_criterion->get_userStatus();
}
    

Ruby

def add_dsa_targeting(adwords, ad_group_id, dsa_page_url_label)
  ad_group_criterion_srv =
      adwords.service(:AdGroupCriterionService, API_VERSION)

  webpage = {
    :xsi_type => 'Webpage',
    :parameter => {
      :criterion_name => 'Test criterion',
      :conditions => [{
        :operand => 'CUSTOM_LABEL',
        :argument => dsa_page_url_label
      }]
    }
  }

  bidding_strategy_configuration = {
    :bids => [{
      :xsi_type => 'CpcBid',
      :bid => {
        :micro_amount => 1_500_000
      }
    }]
  }

  criterion = {
    :xsi_type => 'BiddableAdGroupCriterion',
    :ad_group_id => ad_group_id,
    :criterion => webpage,
    :bidding_strategy_configuration => bidding_strategy_configuration
  }

  operation = {
    :operand => criterion,
    :operator => 'ADD'
  }

  new_criterion = ad_group_criterion_srv.mutate([operation])[:value].first
  puts "Web page criterion with ID %d and status '%s' was created." %
      [new_criterion[:criterion][:id], new_criterion[:user_status]]
end
    

Berichte

Für dynamische Suchanzeigen können Sie drei unterschiedliche Berichte herunterladen.

Leistungsbericht zu Kriterien

Das Feld Parameter oder Dynamic ad target in diesem Bericht enthält in den Fällen, in denen das Kriteriumsobjekt den Typ WebpageCriterion hatte, den Namen des WebpageParameter, der mit diesem Objekt verknüpft ist. Dies ist ein Feld vom Typ attribute, d. h., es enthält unveränderliche Daten, in diesem Fall den WebpageParameter, der den Leistungsdaten zugeordnet ist.

Kategoriebericht ohne Keywords

Der Kategoriebericht ohne Keywords enthält Anzeigen ohne Keywords für Statistiken zu dynamischen Suchanzeigen, die nach Kategorie zusammengefasst sind. Dieser Bericht enthält keine Zeilen mit null Impressionen. In den Feldern Category0, Category1 und Category2 sind die Kategorie- und Unterkategorieinformationen bezüglich der Ergebnisse enthalten.

Kategorien der obersten Ebene Unterkategorien auf erster Ebene Unterkategorien auf zweiter Ebene Klicks Impressionen Tag Kosten
Reise und Tourismus Außerirdisch Mars 1 71 20.06.2014 0,05
Reise und Tourismus Abenteuerreisen 0 279 21.06.2014 0

Suchanfragenbericht ohne Keywords

Der Suchanfragenbericht ohne Keywords enthält Anzeigen ohne Keywords für Statistiken zu dynamischen Suchanzeigen, die auf Suchbegriffen basieren. Dieser Bericht enthält keine Zeilen mit null Impressionen. Das Feld Query enthält übereinstimmende Suchanfragen, die Ergebnisse generiert haben.

Suchbegriff Klicks Impressionen Tag Kosten URL
mars luxus 0 20 20.06.2014 0 http://example.org/LuxuryMarsCruises
mars luxus 0 14 21.06.2014 0 http://example.org/LuxuryMarsCruises
billig mars 0 24 20.06.2014 0 http://example.org/MarsOnABudget
billig mars 0 18 21.06.2014 0 http://example.org/MarsOnABudget
mars sehenswürdigkeiten 0 130 21.06.2014 0 http://example.org/MajorTouristSpots
mars lustiges gesicht 0 44 21.06.2014 0 http://example.org/MajorTouristSpots
raumfahrt sicherheit 1 3 20.06.2014 0,05 http://example.org/ButIsItSafe
mars abflugorte 0 11 21.06.2014 0 http://example.org/HowToGetToMars
mars strände 0 24 20.06.2014 0 http://example.org/MarsBeachVacations
mars strände 0 39 21.06.2014 0 http://example.org/MarsBeachVacations
mars canyoning 0 23 21.06.2014 0 http://example.org/DayTripsAndActivities
Gesamt 1 350 0,05 --

Codebeispiele

Vollständige Codebeispiele zur Verwendung von dynamischen Suchanzeigen finden Sie in der jeweiligen Clientbibliothek:

Feedback geben zu...