So richten Sie dynamische Suchanzeigen mit der Google Ads API ein:
- Erstellen Sie eine Kampagne und geben Sie ihre Domain an.
- Erstellen Sie eine Anzeigengruppe für Funktionen mit Bezug zu dynamischen Suchanzeigen.
- Erstellen Sie eine oder mehrere dynamische Suchanzeigen.
- Geben Sie mindestens ein Kriterium für die Auslieferung der dynamischen Suchanzeigen in der Kampagne an.
Kampagne erstellen
Damit das Google Ads-System weiß, dass Sie dynamische Suchanzeigen in Ihrer Kampagne verwenden, müssen Sie zuerst eine Campaign
erstellen, für die das Feld advertising_channel_type
auf AdvertisingChannelType.SEARCH
festgelegt ist. Geben Sie außerdem eine Domain an, auf der die dynamischen Suchanzeigen ausgeführt werden. Dazu wird das Feld dynamic_search_ads_setting
des Campaign
mithilfe von DynamicSearchAdsSetting
festgelegt.
Im folgenden Beispiel wird eine Kampagne mit dynamischen Suchnetzwerk-Anzeigen erstellt.
Java
private static String addCampaign( GoogleAdsClient googleAdsClient, long customerId, String budgetResourceName) { // Creates the campaign. Campaign campaign = Campaign.newBuilder() .setName("Interplanetary Cruise #" + getPrintableDateTime()) .setAdvertisingChannelType(AdvertisingChannelType.SEARCH) .setStatus(CampaignStatus.PAUSED) .setManualCpc(ManualCpc.newBuilder().build()) .setCampaignBudget(budgetResourceName) // Enables the campaign for DSAs. .setDynamicSearchAdsSetting( DynamicSearchAdsSetting.newBuilder() .setDomainName("example.com") .setLanguageCode("en") .build()) .setStartDate(new DateTime().plusDays(1).toString("yyyyMMdd")) .setEndDate(new DateTime().plusDays(30).toString("yyyyMMdd")) .build(); // Creates the operation. CampaignOperation operation = CampaignOperation.newBuilder().setCreate(campaign).build(); // Creates the campaign service client. try (CampaignServiceClient campaignServiceClient = googleAdsClient.getLatestVersion().createCampaignServiceClient()) { // Adds the campaign. MutateCampaignsResponse response = campaignServiceClient.mutateCampaigns( Long.toString(customerId), ImmutableList.of(operation)); String campaignResourceName = response.getResults(0).getResourceName(); // Displays the results. System.out.printf("Added campaign with resource name '%s'.%n", campaignResourceName); return campaignResourceName; } }
C#
private static string AddCampaign(GoogleAdsClient client, long customerId, string budgetResourceName) { // Get the CampaignService. CampaignServiceClient campaignService = client.GetService(Services.V16.CampaignService); // Create the campaign. Campaign campaign = new Campaign() { Name = "Interplanetary Cruise #" + ExampleUtilities.GetRandomString(), AdvertisingChannelType = AdvertisingChannelType.Search, Status = CampaignStatus.Paused, ManualCpc = new ManualCpc(), CampaignBudget = budgetResourceName, // Enable the campaign for DSAs. DynamicSearchAdsSetting = new DynamicSearchAdsSetting() { DomainName = "example.com", LanguageCode = "en" }, StartDate = DateTime.Now.AddDays(1).ToString("yyyyMMdd"), EndDate = DateTime.Now.AddDays(30).ToString("yyyyMMdd") }; // Create the operation. CampaignOperation operation = new CampaignOperation() { Create = campaign }; // Add the campaign. MutateCampaignsResponse response = campaignService.MutateCampaigns(customerId.ToString(), new CampaignOperation[] { operation }); // Displays the result. string campaignResourceName = response.Results[0].ResourceName; Console.WriteLine($"Added campaign with resource name '{campaignResourceName}'."); return campaignResourceName; }
PHP
private static function createCampaign( GoogleAdsClient $googleAdsClient, int $customerId, string $campaignBudgetResourceName ) { $campaign = new Campaign([ 'name' => 'Interplanetary Cruise #' . Helper::getPrintableDatetime(), 'advertising_channel_type' => AdvertisingChannelType::SEARCH, 'status' => CampaignStatus::PAUSED, 'manual_cpc' => new ManualCpc(), 'campaign_budget' => $campaignBudgetResourceName, // Enables the campaign for DSAs. 'dynamic_search_ads_setting' => new DynamicSearchAdsSetting([ 'domain_name' => 'example.com', 'language_code' => 'en' ]), // Optional: Sets the start and end dates for the campaign, beginning one day from // now and ending a month from now. 'start_date' => date('Ymd', strtotime('+1 day')), 'end_date' => date('Ymd', strtotime('+1 month')) ]); // Creates a campaign operation. $campaignOperation = new CampaignOperation(); $campaignOperation->setCreate($campaign); // Issues a mutate request to add campaigns. $campaignServiceClient = $googleAdsClient->getCampaignServiceClient(); /** @var MutateCampaignsResponse $campaignResponse */ $campaignResponse = $campaignServiceClient->mutateCampaigns( MutateCampaignsRequest::build($customerId, [$campaignOperation]) ); $campaignResourceName = $campaignResponse->getResults()[0]->getResourceName(); printf("Added campaign named '%s'.%s", $campaignResourceName, PHP_EOL); return $campaignResourceName; }
Python
def create_campaign(client, customer_id, budget_resource_name): """Creates a Dynamic Search Ad Campaign under the given customer ID. Args: client: an initialized GoogleAdsClient instance. customer_id: a client customer ID str. budget_resource_name: a resource_name str for a Budget Returns: A resource_name str for the newly created Campaign. """ # Retrieve a new campaign operation object. campaign_operation = client.get_type("CampaignOperation") campaign = campaign_operation.create campaign.name = f"Interplanetary Cruise #{uuid4()}" campaign.advertising_channel_type = ( client.enums.AdvertisingChannelTypeEnum.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 = client.enums.CampaignStatusEnum.PAUSED campaign.manual_cpc.enhanced_cpc_enabled = True campaign.campaign_budget = budget_resource_name # Required: Enable the campaign for DSAs by setting the campaign's dynamic # search ads setting domain name and language. campaign.dynamic_search_ads_setting.domain_name = "example.com" campaign.dynamic_search_ads_setting.language_code = "en" # Optional: Sets the start and end dates for the campaign, beginning one day # from now and ending a month from now. campaign.start_date = (datetime.now() + timedelta(days=1)).strftime( "%Y%m%d" ) campaign.end_date = (datetime.now() + timedelta(days=30)).strftime("%Y%m%d") # Retrieve the campaign service. campaign_service = client.get_service("CampaignService") # Issues a mutate request to add campaign. response = campaign_service.mutate_campaigns( customer_id=customer_id, operations=[campaign_operation] ) resource_name = response.results[0].resource_name print(f'Created campaign with resource_name: "{resource_name}"')
Ruby
def create_campaign(client, customer_id, budget_resource_name) campaign = client.resource.campaign do |c| c.name = "Interplanetary Cruise #{(Time.now.to_f * 1000).to_i}" c.advertising_channel_type = :SEARCH c.status = :PAUSED c.manual_cpc = client.resource.manual_cpc c.campaign_budget = budget_resource_name c.dynamic_search_ads_setting = client.resource.dynamic_search_ads_setting do |s| s.domain_name = "example.com" s.language_code = "en" end c.start_date = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d') c.end_date = DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d') end operation = client.operation.create_resource.campaign(campaign) response = client.service.campaign.mutate_campaigns( customer_id: customer_id, operations: [operation], ) puts("Created campaign with ID: #{response.results.first.resource_name}") response.results.first.resource_name end
Perl
sub create_campaign { my ($api_client, $customer_id, $campaign_budget_resource_name) = @_; # Create a campaign. my $campaign = Google::Ads::GoogleAds::V16::Resources::Campaign->new({ name => "Interplanetary Cruise #" . uniqid(), advertisingChannelType => SEARCH, status => Google::Ads::GoogleAds::V16::Enums::CampaignStatusEnum::PAUSED, manualCpc => Google::Ads::GoogleAds::V16::Common::ManualCpc->new(), campaignBudget => $campaign_budget_resource_name, # Enable the campaign for DSAs. dynamicSearchAdsSetting => Google::Ads::GoogleAds::V16::Resources::DynamicSearchAdsSetting->new({ domainName => "example.com", languageCode => "en" } ), # Optional: Set the start and end dates for the campaign, beginning one day from # now and ending a month from now. startDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24)), endDate => strftime("%Y%m%d", localtime(time + 60 * 60 * 24 * 30)), }); # Create a campaign operation. my $campaign_operation = Google::Ads::GoogleAds::V16::Services::CampaignService::CampaignOperation-> new({create => $campaign}); # Add the campaign. my $campaigns_response = $api_client->CampaignService()->mutate({ customerId => $customer_id, operations => [$campaign_operation]}); my $campaign_resource_name = $campaigns_response->{results}[0]{resourceName}; printf "Created campaign '%s'.\n", $campaign_resource_name; return $campaign_resource_name; }
Anzeigengruppe erstellen
Wenn Sie Funktionen für dynamische Suchanzeigen verwenden möchten, müssen Sie eine AdGroup
erstellen und das Feld type
auf SEARCH_DYNAMIC_ADS
setzen.
Für diesen Anzeigengruppentyp gelten die folgenden Einschränkungen:
- Dieser Anzeigengruppentyp kann nur Suchnetzwerk-Kampagnen hinzugefügt werden.
- Auf Kampagnenebene muss ein gültiger
DynamicSearchAdsSetting
festgelegt sein - hinzugefügt werden soll. Wenn diese Einstellung fehlt, wird der Fehler
AdGroupError.CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTING
ausgegeben. - In Anzeigengruppen dieses Typs sind keine einzuschließenden Keywords zulässig. Zielgruppen, dynamische Anzeigenziele und auszuschließende Keywords sind zulässig.
- Wie bei allen Anzeigengruppen kann das Feld
type
nach dem Erstellen nicht mehr geändert werden. - In dieser Anzeigengruppe sind nur Anzeigenformate mit dynamischen Suchanzeigen zulässig.
Mit dem folgenden Codebeispiel wird eine SEARCH_DYNAMIC_ADS
-Anzeigengruppe erstellt.
Java
private static String addAdGroup( GoogleAdsClient googleAdsClient, long customerId, String campaignResourceName) { // Creates the ad group. AdGroup adGroup = AdGroup.newBuilder() .setName("Earth to Mars Cruises #" + getPrintableDateTime()) .setCampaign(campaignResourceName) .setType(AdGroupType.SEARCH_DYNAMIC_ADS) .setStatus(AdGroupStatus.PAUSED) .setTrackingUrlTemplate("http://tracker.examples.com/traveltracker/{escapedlpurl}") .setCpcBidMicros(50_000) .build(); // Creates the operation. AdGroupOperation operation = AdGroupOperation.newBuilder().setCreate(adGroup).build(); // Creates the ad group service client. try (AdGroupServiceClient adGroupServiceClient = googleAdsClient.getLatestVersion().createAdGroupServiceClient()) { MutateAdGroupsResponse response = adGroupServiceClient.mutateAdGroups( Long.toString(customerId), ImmutableList.of(operation)); String adGroupResourceName = response.getResults(0).getResourceName(); // Displays the results. System.out.printf("Added ad group with resource name '%s'.%n", adGroupResourceName); return adGroupResourceName; } }
C#
private static string AddAdGroup(GoogleAdsClient client, long customerId, string campaignResourceName) { // Get the AdGroupService. AdGroupServiceClient adGroupService = client.GetService(Services.V16.AdGroupService); // Create the ad group. AdGroup adGroup = new AdGroup() { Name = "Earth to Mars Cruises #" + ExampleUtilities.GetRandomString(), Campaign = campaignResourceName, Type = AdGroupType.SearchDynamicAds, Status = AdGroupStatus.Paused, TrackingUrlTemplate = "http://tracker.examples.com/traveltracker/{escapedlpurl}", CpcBidMicros = 50_000 }; // Create the operation. AdGroupOperation operation = new AdGroupOperation() { Create = adGroup }; // Add the ad group. MutateAdGroupsResponse response = adGroupService.MutateAdGroups(customerId.ToString(), new AdGroupOperation[] { operation }); // Display the results. string adGroupResourceName = response.Results[0].ResourceName; Console.WriteLine($"Added ad group with resource name '{adGroupResourceName}'."); return adGroupResourceName; }
PHP
private static function createAdGroup( GoogleAdsClient $googleAdsClient, int $customerId, string $campaignResourceName ) { // Constructs an ad group and sets an optional CPC value. $adGroup = new AdGroup([ 'name' => 'Earth to Mars Cruises #' . Helper::getPrintableDatetime(), 'campaign' => $campaignResourceName, 'status' => AdGroupStatus::PAUSED, 'type' => AdGroupType::SEARCH_DYNAMIC_ADS, 'tracking_url_template' => 'http://tracker.examples.com/traveltracker/{escapedlpurl}', 'cpc_bid_micros' => 10000000 ]); // Creates an ad group operation. $adGroupOperation = new AdGroupOperation(); $adGroupOperation->setCreate($adGroup); // Issues a mutate request to add the ad groups. $adGroupServiceClient = $googleAdsClient->getAdGroupServiceClient(); /** @var MutateAdGroupsResponse $adGroupResponse */ $adGroupResponse = $adGroupServiceClient->mutateAdGroups( MutateAdGroupsRequest::build($customerId, [$adGroupOperation]) ); $adGroupResourceName = $adGroupResponse->getResults()[0]->getResourceName(); printf("Added ad group named '%s'.%s", $adGroupResourceName, PHP_EOL); return $adGroupResourceName; }
Python
def create_ad_group(client, customer_id, campaign_resource_name): """Creates a Dynamic Search Ad Group under the given Campaign. Args: client: an initialized GoogleAdsClient instance. customer_id: a client customer ID str. campaign_resource_name: a resource_name str for a Campaign. Returns: A resource_name str for the newly created Ad Group. """ # Retrieve a new ad group operation object. ad_group_operation = client.get_type("AdGroupOperation") # Create an ad group. ad_group = ad_group_operation.create # Required: set the ad group's type to Dynamic Search Ads. ad_group.type_ = client.enums.AdGroupTypeEnum.SEARCH_DYNAMIC_ADS ad_group.name = f"Earth to Mars Cruises {uuid4()}" ad_group.campaign = campaign_resource_name ad_group.status = client.enums.AdGroupStatusEnum.PAUSED # Recommended: set a tracking URL template for your ad group if you want to # use URL tracking software. ad_group.tracking_url_template = ( "http://tracker.example.com/traveltracker/{escapedlpurl}" ) # Optional: Set the ad group bid value. ad_group.cpc_bid_micros = 10000000 # Retrieve the ad group service. ad_group_service = client.get_service("AdGroupService") # Issues a mutate request to add the ad group. response = ad_group_service.mutate_ad_groups( customer_id=customer_id, operations=[ad_group_operation] ) resource_name = response.results[0].resource_name print(f'Created Ad Group with resource_name: "{resource_name}"')
Ruby
def create_ad_group(client, customer_id, campaign_resource_name) ad_group = client.resource.ad_group do |ag| ag.type = :SEARCH_DYNAMIC_ADS ag.name = "Earth to Mars Cruises #{(Time.now.to_f * 1000).to_i}" ag.campaign = campaign_resource_name ag.status = :PAUSED ag.tracking_url_template = "http://tracker.example.com/traveltracker/{escapedlpurl}" ag.cpc_bid_micros = 3_000_000 end operation = client.operation.create_resource.ad_group(ad_group) response = client.service.ad_group.mutate_ad_groups( customer_id: customer_id, operations: [operation], ) puts("Created ad group with ID: #{response.results.first.resource_name}") response.results.first.resource_name end
Perl
sub create_ad_group { my ($api_client, $customer_id, $campaign_resource_name) = @_; # Construct an ad group and set an optional CPC value. my $ad_group = Google::Ads::GoogleAds::V16::Resources::AdGroup->new({ name => "Earth to Mars Cruises #" . uniqid(), campaign => $campaign_resource_name, status => Google::Ads::GoogleAds::V16::Enums::AdGroupStatusEnum::PAUSED, type => SEARCH_DYNAMIC_ADS, trackingUrlTemplate => "http://tracker.examples.com/traveltracker/{escapedlpurl}", cpcBidMicros => 3000000 }); # Create an ad group operation. my $ad_group_operation = Google::Ads::GoogleAds::V16::Services::AdGroupService::AdGroupOperation-> new({create => $ad_group}); # Add the ad group. my $ad_groups_response = $api_client->AdGroupService()->mutate({ customerId => $customer_id, operations => [$ad_group_operation]}); my $ad_group_resource_name = $ad_groups_response->{results}[0]{resourceName}; printf "Created ad group '%s'.\n", $ad_group_resource_name; return $ad_group_resource_name; }
Dynamische Suchanzeige erstellen
Um die eigentliche DSA zu erstellen, müssen Sie ein ExpandedDynamicSearchAdInfo
-Objekt verwenden und die folgenden Felder festlegen:
- Erforderlich:
description
- Optional:
description2
Bei dieser Anzeige werden der Anzeigentitel, die angezeigte URL und die finale URL bei der Auslieferung automatisch generiert. Dabei werden die spezifischen Informationen zum Domainnamen berücksichtigt, die in der DynamicSearchAdsSetting
auf Kampagnenebene angegeben wurden.
Java
private static void addExpandedDSA( GoogleAdsClient googleAdsClient, long customerId, String adGroupResourceName) { // Creates an ad group ad. AdGroupAd adGroupAd = AdGroupAd.newBuilder() .setAdGroup(adGroupResourceName) .setStatus(AdGroupAdStatus.PAUSED) // Sets the ad as an expanded dynamic search ad .setAd( Ad.newBuilder() .setExpandedDynamicSearchAd( ExpandedDynamicSearchAdInfo.newBuilder() .setDescription("Buy tickets now!") .build()) .build()) .build(); // Creates the operation. AdGroupAdOperation operation = AdGroupAdOperation.newBuilder().setCreate(adGroupAd).build(); // Creates the ad group ad service client. try (AdGroupAdServiceClient adGroupAdServiceClient = googleAdsClient.getLatestVersion().createAdGroupAdServiceClient()) { // Adds the dynamic search ad. MutateAdGroupAdsResponse response = adGroupAdServiceClient.mutateAdGroupAds( Long.toString(customerId), ImmutableList.of(operation)); // Displays the response. System.out.printf( "Added ad group ad with resource name '%s'.%n", response.getResults(0).getResourceName()); } }
C#
private static void AddExpandedDSA(GoogleAdsClient client, long customerId, string adGroupResourceName) { // Get the AdGroupAdService. AdGroupAdServiceClient adGroupAdService = client.GetService(Services.V16.AdGroupAdService); // Create an ad group ad. AdGroupAd adGroupAd = new AdGroupAd() { AdGroup = adGroupResourceName, Status = AdGroupAdStatus.Paused, // Set the ad as an expanded dynamic search ad. Ad = new Ad() { ExpandedDynamicSearchAd = new ExpandedDynamicSearchAdInfo() { Description = "Buy tickets now!" } } }; // Create the operation. AdGroupAdOperation operation = new AdGroupAdOperation() { Create = adGroupAd }; // Add the dynamic search ad. MutateAdGroupAdsResponse response = adGroupAdService.MutateAdGroupAds( customerId.ToString(), new AdGroupAdOperation[] { operation }); // Display the response. Console.WriteLine($"Added ad group ad with resource name " + $"'{response.Results[0].ResourceName}'."); }
PHP
private static function createExpandedDSA( GoogleAdsClient $googleAdsClient, int $customerId, string $adGroupResourceName ) { $adGroupAd = new AdGroupAd([ 'ad_group' => $adGroupResourceName, 'status' => AdGroupAdStatus::PAUSED, 'ad' => new Ad([ 'expanded_dynamic_search_ad' => new ExpandedDynamicSearchAdInfo([ 'description' => 'Buy tickets now!' ]) ]) ]); $adGroupAdOperation = new AdGroupAdOperation(); $adGroupAdOperation->setCreate($adGroupAd); // Issues a mutate request to add the ad group ads. $adGroupAdServiceClient = $googleAdsClient->getAdGroupAdServiceClient(); /** @var MutateAdGroupAdsResponse $adGroupAdResponse */ $adGroupAdResponse = $adGroupAdServiceClient->mutateAdGroupAds( MutateAdGroupAdsRequest::build($customerId, [$adGroupAdOperation]) ); $adGroupAdResourceName = $adGroupAdResponse->getResults()[0]->getResourceName(); printf("Added ad group ad named '%s'.%s", $adGroupAdResourceName, PHP_EOL); return $adGroupAdResourceName; }
Python
def create_expanded_dsa(client, customer_id, ad_group_resource_name): """Creates a dynamic search ad under the given ad group. Args: client: an initialized GoogleAdsClient instance. customer_id: a client customer ID str. ad_group_resource_name: a resource_name str for an Ad Group. """ # Retrieve a new ad group ad operation object. ad_group_ad_operation = client.get_type("AdGroupAdOperation") # Create and 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 DynamicSearchAdSetting at # the campaign level. ad_group_ad = ad_group_ad_operation.create # Optional: set the ad status. ad_group_ad.status = client.enums.AdGroupAdStatusEnum.PAUSED # Set the ad description. ad_group_ad.ad.expanded_dynamic_search_ad.description = "Buy tickets now!" ad_group_ad.ad_group = ad_group_resource_name # Retrieve the ad group ad service. ad_group_ad_service = client.get_service("AdGroupAdService") # Submit the ad group ad operation to add the ad group ad. response = ad_group_ad_service.mutate_ad_group_ads( customer_id=customer_id, operations=[ad_group_ad_operation] ) resource_name = response.results[0].resource_name print(f'Created Ad Group Ad with resource_name: "{resource_name}"')
Ruby
def create_expanded_dsa(client, customer_id, ad_group_resource_name) ad_group_ad = client.resource.ad_group_ad do |aga| aga.status = :PAUSED aga.ad = client.resource.ad do |ad| ad.expanded_dynamic_search_ad = client.resource.expanded_dynamic_search_ad_info do |info| info.description = "Buy tickets now!" end end aga.ad_group = ad_group_resource_name end operation = client.operation.create_resource.ad_group_ad(ad_group_ad) response = client.service.ad_group_ad.mutate_ad_group_ads( customer_id: customer_id, operations: [operation], ) puts("Created ad group ad with ID: #{response.results.first.resource_name}") end
Perl
sub create_expanded_dsa { my ($api_client, $customer_id, $ad_group_resource_name) = @_; # Create an ad group ad. my $ad_group_ad = Google::Ads::GoogleAds::V16::Resources::AdGroupAd->new({ adGroup => $ad_group_resource_name, status => Google::Ads::GoogleAds::V16::Enums::AdGroupAdStatusEnum::PAUSED, ad => Google::Ads::GoogleAds::V16::Resources::Ad->new({ expandedDynamicSearchAd => Google::Ads::GoogleAds::V16::Common::ExpandedDynamicSearchAdInfo-> new({ description => "Buy tickets now!" })})}); # Create an ad group ad operation. my $ad_group_ad_operation = Google::Ads::GoogleAds::V16::Services::AdGroupAdService::AdGroupAdOperation ->new({create => $ad_group_ad}); # Add the ad group ad. my $ad_group_ads_response = $api_client->AdGroupAdService()->mutate({ customerId => $customer_id, operations => [$ad_group_ad_operation]}); my $ad_group_ad_resource_name = $ad_group_ads_response->{results}[0]{resourceName}; printf "Created ad group ad '%s'.\n", $ad_group_ad_resource_name; return $ad_group_ad_resource_name; }
Das Feld final_urls
wird in Google Ads beim Erstellen der dynamischen Suchanzeige berechnet. Sie können daher dieses Feld beim Erstellen von dynamischen Suchanzeigen nicht festlegen. Wenn Sie URL-Tracking-Software verwenden möchten, können Sie mit dem Feld tracking_url_template
angeben, welche zusätzlichen Tracking-Parameter oder Weiterleitungen erforderlich sind. Dabei müssen Sie einen der folgenden Parameter einschließen, damit Google Ads die resultierende übereinstimmende finale URL einbinden kann:
Parameter | Erklärung |
---|---|
{unescapedlpurl} |
Nicht umschriebene Zielseiten-URL. Wenn Sie etwas am Ende hinzufügen möchten. Beispiel:
|
{escapedlpurl} |
Umschriebene (URL-codierte) Zielseiten-URL. Wenn Sie zu einem Tracker umleiten möchten. Beispiel:
|
{lpurlpath} |
Nur Pfad und Abfrageparameter aus der berechneten URL. Beispiel:
|
{lpurl} |
Codiert
|
Beispiel:
Java
dsa.setTrackingUrlTemplate(
StringValue.of("http://example.com/traveltracker/{escapedlpurl}"));
Kriterien für dynamische Suchanzeigen angeben
Abschließend sollten Sie Kriterien einrichten, die die Auslieferung der dynamischen Suchanzeigen auslösen.
Dazu wird das Feld webpage
von AdGroupCriterion
verwendet. Das Feld webpage
wird als WebpageInfo
-Objekt festgelegt, das ein bis drei conditions
-Objekte zulässt.
Bei diesen conditions
-Instanzen handelt es sich um WebpageConditionInfo
-Instanzen, mit denen Sie genau angeben können, wonach innerhalb der Domain gefiltert oder gesucht werden soll, die zuvor in den Kampagneneinstellungen festgelegt wurde. Innerhalb einer Domain können Sie
nach fünf Elementen filtern:
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. Weitere Informationen finden Sie unter URL des Ziel-Seitenfeeds mithilfe von benutzerdefinierten Labels. |
Sie könnten beispielsweise ein Webseitenkriterium erstellen, das auf alle Seiten im Zweig /children
einer Urlaubswebsite (URL
-Bedingung) ausgerichtet ist, aber nur auf Seiten mit „Sonderangebot“ im Titel (Bedingung PAGE_TITLE
).
Kategorien der Website ermitteln
Sie können die Liste der DomainCategory
s abrufen und filtern, von denen Google annimmt, dass sie auf Ihre Website zutreffen. Dazu wählen Sie in einer GAQL-Abfrage Felder der Ressource domain_category
aus.
Mit der folgenden GAQL-Abfrage wird die Liste der Domainkategorien für eine bestimmte Website und eine bestimmte Kampagne abgerufen und nach der ID gefiltert:
SELECT
domain_category.category,
domain_category.language_code,
domain_category.recommended_cpc_bid_micros
FROM domain_category
WHERE domain_category.domain = 'example.com'
AND campaign.id = campaign_id
Ausschließen von Websiteteilen
Sie können auch AdGroupCriterionService
verwenden, um auszuschließende Webseitenkriterien einzurichten. Damit können Sie beispielsweise Seiten mit einem bestimmten Titel ausschließen, die Sie mit einer anderen Kampagne oder Anzeigengruppe verwalten möchten.
Weitere Kriterien
Kampagnen und Anzeigengruppen mit dynamischen Suchanzeigen sind nicht auf Webseitenkriterien beschränkt. Sie können weiterhin andere Kriterientypen verwenden, um die Qualität Ihrer Anzeigen weiter zu optimieren. Zusätzliche Kriterien sollten jedoch mit Bedacht eingesetzt werden, da dies die Effektivität der automatischen Ausrichtung von dynamischen Suchanzeigen beeinträchtigen kann.