Crea annunci dinamici della rete di ricerca

Per configurare gli annunci dinamici della rete di ricerca (DSA) con l'API Google Ads:

1. Crea una campagna e specifica il dominio e il codice lingua.
2. Crea un gruppo di annunci per le funzionalità correlate ai DSA.
3. Crea uno o più DSA.
4. Specifica uno o più criteri per la pubblicazione dei DSA nella campagna.

Crea la campagna

Per configurare i DSA nella campagna, crea un Campaign con advertising_channel_type impostato su AdvertisingChannelType.SEARCH. Inoltre, specifica il dominio del sito web (domain_name, senza http:// o https://) e la lingua (language_code) in cui operano i DSA impostando il campo dynamic_search_ads_setting di Campaign utilizzando un DynamicSearchAdsSetting. Sia domain_name sia language_code sono obbligatori. Puoi anche impostare use_supplied_urls_only su DynamicSearchAdsSetting (true limita il targeting solo agli URL dei feed di pagine DSA; false utilizza sia l'indice di Google del tuo dominio sia gli URL dei feed di pagine).

L'esempio seguente crea una campagna DSA:

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())
          // Declares whether this campaign serves political ads targeting the EU.
          .setContainsEuPoliticalAdvertising(DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING)
          .setStartDateTime(new DateTime().plusDays(1).toString("yyyy-MM-dd 00:00:00"))
          .setEndDateTime(new DateTime().plusDays(30).toString("yyyy-MM-dd 23:59:59"))
          .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;
  }
}
AddDynamicSearchAds.java
      

C#

private static string AddCampaign(GoogleAdsClient client, long customerId,
    string budgetResourceName)
{
    // Get the CampaignService.
    CampaignServiceClient campaignService = client.GetService(Services.V25.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"
        },

        // Declare whether or not this campaign contains political ads targeting the EU.
        ContainsEuPoliticalAdvertising = EuPoliticalAdvertisingStatus.DoesNotContainEuPoliticalAdvertising,

        StartDateTime = DateTime.Now.AddDays(1).ToString("yyyyMMdd 00:00:00"),
        EndDateTime = DateTime.Now.AddDays(30).ToString("yyyyMMdd 23:59:59")
    };

    // 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;
}
AddDynamicSearchAds.cs
      

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'
                ]
            ),
            // Declare whether or not this campaign serves political ads targeting the EU.
            'contains_eu_political_advertising' =>
                EuPoliticalAdvertisingStatus::DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING,
            // Optional: Sets the start and end dates for the campaign, beginning one day from
            // now and ending a month from now.
            'start_date_time' => date('Y-m-d 00:00:00', strtotime('+1 day')),
            'end_date_time' => date('Y-m-d 23:59:59', 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;
    }
AddDynamicSearchAds.php
      

Python

def create_campaign(
    client: GoogleAdsClient, customer_id: str, budget_resource_name: str
) -> str:
    """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: CampaignOperation = client.get_type("CampaignOperation")
    campaign: 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"

    # Declare whether or not this campaign serves political ads targeting the
    # EU. Valid values are:
    #   CONTAINS_EU_POLITICAL_ADVERTISING
    #   DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    campaign.contains_eu_political_advertising = (
        client.enums.EuPoliticalAdvertisingStatusEnum.DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    )

    # Optional: Sets the start and end dates for the campaign, beginning one day
    # from now and ending a month from now.
    campaign.start_date_time = (datetime.now() + timedelta(days=1)).strftime(
        "%Y%m%d 00:00:00"
    )
    campaign.end_date_time = (datetime.now() + timedelta(days=30)).strftime(
        "%Y%m%d 23:59:59"
    )

    # Retrieve the campaign service.
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )

    # Issues a mutate request to add campaign.
    response: MutateCampaignsResponse = campaign_service.mutate_campaigns(
        customer_id=customer_id, operations=[campaign_operation]
    )
    resource_name: str = response.results[0].resource_name

    print(f'Created campaign with resource_name: "{resource_name}"')
add_dynamic_search_ads.py
      

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

    # Declare whether or not this campaign serves political ads targeting the EU.
    # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
    # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING.
    c.contains_eu_political_advertising = :DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING

    c.start_date_time = DateTime.parse((Date.today + 1).to_s).strftime('%Y%m%d %H:%M:%S')
    c.end_date_time = DateTime.parse(Date.today.next_year.to_s).strftime('%Y%m%d %H:%M:%S')
  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
add_dynamic_search_ads.rb
      

Perl

sub create_campaign {
  my ($api_client, $customer_id, $campaign_budget_resource_name) = @_;

  # Create a campaign.
  my $campaign = Google::Ads::GoogleAds::V25::Resources::Campaign->new({
      name                   => "Interplanetary Cruise #" . uniqid(),
      advertisingChannelType => SEARCH,
      status => Google::Ads::GoogleAds::V25::Enums::CampaignStatusEnum::PAUSED,
      manualCpc      => Google::Ads::GoogleAds::V25::Common::ManualCpc->new(),
      campaignBudget => $campaign_budget_resource_name,
      # Enable the campaign for DSAs.
      dynamicSearchAdsSetting =>
        Google::Ads::GoogleAds::V25::Resources::DynamicSearchAdsSetting->new({
          domainName   => "example.com",
          languageCode => "en"
        }
        ),
      # Optional: Set the start and end datetimes for the campaign, beginning one day from
      # now and ending a month from now.
      startDateTime =>
        strftime("%Y%m%d 00:00:00", localtime(time + 60 * 60 * 24)),
      endDateTime =>
        strftime("%Y%m%d 23:59:59", localtime(time + 60 * 60 * 24 * 30)),
      # Declare whether or not this campaign serves political ads targeting the EU.
      # Valid values are CONTAINS_EU_POLITICAL_ADVERTISING and
      # DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING.
      containsEuPoliticalAdvertising =>
        DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    });

  # Create a campaign operation.
  my $campaign_operation =
    Google::Ads::GoogleAds::V25::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;
}
add_dynamic_search_ads.pl
      

curl

Nota: anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenerlo utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche del metodo. Dovrai creare il payload JSON in base alle definizioni proto.

Key Resources:

• Using REST
• REST Interface Structure
• JSON Field Mappings
• Consulta il Riferimento API REST per il servizio e il metodo specifici.

Crea il gruppo di annunci

Per utilizzare le funzionalità DSA, crea un AdGroup con il type campo impostato su SEARCH_DYNAMIC_ADS. Questo tipo di gruppo di annunci applica le seguenti restrizioni:

• Questo tipo di gruppo di annunci può essere aggiunto solo alle campagne sulla rete di ricerca.
• Prima di aggiungere il gruppo di annunci, è necessario impostare un DynamicSearchAdsSetting valido a livello di campagna. In caso contrario, l'API restituisce un AdGroupError con CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTING.
• Le parole chiave positive non sono consentite in questo tipo di gruppo di annunci. Sono consentiti i targeting per pubblico, i target degli annunci dinamici (webpage) e le parole chiave escluse.
• Come per tutti i gruppi di annunci, il campo type non può essere modificato dopo la creazione.
• In questo gruppo di annunci sono consentiti solo i formati degli annunci correlati ai DSA.

L'esempio di codice seguente mostra come creare un gruppo di annunci SEARCH_DYNAMIC_ADS:

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;
  }
}
AddDynamicSearchAds.java
      

C#

private static string AddAdGroup(GoogleAdsClient client, long customerId,
    string campaignResourceName)
{
    // Get the AdGroupService.
    AdGroupServiceClient adGroupService = client.GetService(Services.V25.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;
}
AddDynamicSearchAds.cs
      

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;
    }
AddDynamicSearchAds.php
      

Python

def create_ad_group(
    client: GoogleAdsClient, customer_id: str, campaign_resource_name: str
) -> str:
    """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: AdGroupOperation = client.get_type("AdGroupOperation")
    # Create an ad group.
    ad_group: AdGroup = 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: AdGroupServiceClient = client.get_service(
        "AdGroupService"
    )

    # Issues a mutate request to add the ad group.
    response: MutateAdGroupsResponse = ad_group_service.mutate_ad_groups(
        customer_id=customer_id, operations=[ad_group_operation]
    )
    resource_name: str = response.results[0].resource_name

    print(f'Created Ad Group with resource_name: "{resource_name}"')
add_dynamic_search_ads.py
      

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

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::V25::Resources::AdGroup->new({
    name     => "Earth to Mars Cruises #" . uniqid(),
    campaign => $campaign_resource_name,
    status   => Google::Ads::GoogleAds::V25::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::V25::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;
}
add_dynamic_search_ads.pl
      

curl

Nota: anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenerlo utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche del metodo. Dovrai creare il payload JSON in base alle definizioni proto.

Key Resources:

• Using REST
• REST Interface Structure
• JSON Field Mappings
• Consulta il Riferimento API REST per il servizio e il metodo specifici.

Crea il DSA

Per creare il DSA, crea un'istanza di un ExpandedDynamicSearchAdInfo oggetto e imposta i seguenti campi:

• Obbligatorio: description
• Facoltativo: description2

Il titolo, l'URL di visualizzazione e l'URL finale dell'annuncio vengono generati automaticamente al momento della pubblicazione in base alle informazioni specifiche del dominio fornite da DynamicSearchAdsSetting configurato a livello di campagna.

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());
  }
}
AddDynamicSearchAds.java
      

C#

private static void AddExpandedDSA(GoogleAdsClient client, long customerId,
    string adGroupResourceName)
{
    // Get the AdGroupAdService.
    AdGroupAdServiceClient adGroupAdService =
        client.GetService(Services.V25.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}'.");
}
AddDynamicSearchAds.cs
      

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;
    }
AddDynamicSearchAds.php
      

Python

def create_expanded_dsa(
    client: GoogleAdsClient, customer_id: str, ad_group_resource_name: str
) -> None:
    """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: AdGroupAdOperation = 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: AdGroupAd = 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: AdGroupAdServiceClient = client.get_service(
        "AdGroupAdService"
    )

    # Submit the ad group ad operation to add the ad group ad.
    response: MutateAdGroupAdsResponse = (
        ad_group_ad_service.mutate_ad_group_ads(
            customer_id=customer_id, operations=[ad_group_ad_operation]
        )
    )
    resource_name: str = response.results[0].resource_name

    print(f'Created Ad Group Ad with resource_name: "{resource_name}"')
add_dynamic_search_ads.py
      

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

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::V25::Resources::AdGroupAd->new({
      adGroup => $ad_group_resource_name,
      status => Google::Ads::GoogleAds::V25::Enums::AdGroupAdStatusEnum::PAUSED,
      ad     => Google::Ads::GoogleAds::V25::Resources::Ad->new({
          expandedDynamicSearchAd =>
            Google::Ads::GoogleAds::V25::Common::ExpandedDynamicSearchAdInfo->
            new({
              description => "Buy tickets now!"
            })})});

  # Create an ad group ad operation.
  my $ad_group_ad_operation =
    Google::Ads::GoogleAds::V25::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;
}
add_dynamic_search_ads.pl
      

curl

Nota: anche se qui non viene fornito un esempio di codice REST diretto per questo passaggio, puoi ottenerlo utilizzando una richiesta REST manuale.

Consulta la documentazione dell'interfaccia REST dell'API Google Ads e le pagine di riferimento specifiche del metodo. Dovrai creare il payload JSON in base alle definizioni proto.

Key Resources:

• Using REST
• REST Interface Structure
• JSON Field Mappings
• Consulta il Riferimento API REST per il servizio e il metodo specifici.

Poiché final_urls viene calcolato dinamicamente da Google Ads, non devi impostare final_urls sull'oggetto Ad principale quando crei un DSA. Per utilizzare il software di monitoraggio degli URL, puoi configurare i modelli di monitoraggio utilizzando il campo tracking_url_template nell'oggetto Ad principale (Ad.tracking_url_template, non in ExpandedDynamicSearchAdInfo), o a livello di AdGroup (come mostrato nello snippet del gruppo di annunci precedente) o Campaign. Quando specifichi questo campo, includi uno dei seguenti parametri ValueTrack in modo che Google Ads possa inserire l'URL finale corrispondente:

Parametro	Spiegazione
{unescapedlpurl}	URL pagina di destinazione senza escape: utilizzalo quando aggiungi parametri di query alla fine, ad esempio: {unescapedlpurl}?dsa=true
{escapedlpurl}	URL pagina di destinazione con escape (codificato in URL): utilizzalo quando esegui il reindirizzamento tramite un tracker di terze parti, ad esempio: https://tracking.example.com/?lp={escapedlpurl}
{lpurlpath}	Solo il percorso e i parametri di query dell'URL calcolato, ad esempio: https://tracking.example.com/track/{lpurlpath}
{lpurl}	Codifica ? e = dell'URL pagina di destinazione e termina con la query di ricerca. Se inserito all'inizio del tracking_url_template campo, viene sostituito dal {unescapedlpurl} valore, ad esempio: https://tracking.example.com/redir.php?tracking=xyz&url={lpurl}

Ad esempio, in Java, imposta tracking_url_template nel builder Ad:

adBuilder.setTrackingUrlTemplate(
    "https://example.com/traveltracker/{escapedlpurl}");

Specifica i criteri per il DSA

Infine, configura i criteri per attivare la pubblicazione dei DSA utilizzando il webpage campo di AdGroupCriterion (vedi l 'esempio completo Aggiungi annunci dinamici della rete di ricerca). Imposta webpage su un WebpageInfo oggetto con un criterion_name obbligatorio (obbligatorio su CREATE e vietato su UPDATE) e fino a tre conditions (collegate logicamente con AND-ed insieme quando vengono valutate; un elenco conditions vuoto ha come target tutte le pagine del sito web della campagna).

Questi conditions sono WebpageConditionInfo istanze che specificano cosa filtrare o trovare nel dominio configurato nelle impostazioni della campagna utilizzando un operand, un argument e un operator facoltativo (EQUALS o CONTAINS). Puoi filtrare in base a cinque tipi di operandi:

WebpageConditionOperand	Descrizione
URL	Una stringa che corrisponde a un URL parziale di una pagina.
CATEGORY	Una stringa con una categoria da confrontare con precisione.
PAGE_TITLE	Una stringa che corrisponde a un titolo di pagina parziale.
PAGE_CONTENT	Una stringa che corrisponde ai contenuti di qualsiasi pagina indicizzata.
CUSTOM_LABEL	Una stringa che corrisponde a una condizione di targeting con etichetta personalizzata della pagina web. Consulta Includere gli URL di destinazione utilizzando le etichette personalizzate.

Ad esempio, puoi creare un criterio per la pagina web che ha come target le pagine nel percorso /children di un sito di viaggi (condizione URL) che contengono anche "Offerta speciale" nel titolo (condizione PAGE_TITLE).

Scopri le categorie del sito

Puoi recuperare e filtrare l'elenco degli DomainCategory oggetti che Google Ads identifica per il tuo sito eseguendo una query sulla domain_category risorsa in GAQL.

La seguente query GAQL recupera le categorie di dominio per un sito e una campagna specifici:

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

Escludi i target delle pagine web

Puoi anche utilizzare AdGroupCriterionService per creare criteri webpage esclusi (impostando negative = true su AdGroupCriterion). Ad esempio, puoi escludere le pagine con un titolo specifico che gestisci in una campagna o in un gruppo di annunci separato.

Altri criteri

Le campagne e i gruppi di annunci DSA non sono limitati solo ai criteri delle pagine web; puoi combinarli con altri tipi di criteri per perfezionare il targeting. Tuttavia, utilizza i criteri aggiuntivi con giudizio, perché un targeting eccessivamente restrittivo può ridurre l'efficacia del targeting automatico dei DSA.