Créer des annonces dynamiques du Réseau de Recherche

Pour configurer des annonces dynamiques du Réseau de Recherche (ADR) avec l'API Google Ads, procédez comme suit :

1. Créez une campagne et spécifiez son domaine et son code de langue.
2. Créez un groupe d'annonces pour les fonctionnalités liées aux annonces dynamiques du Réseau de Recherche.
3. Créez une ou plusieurs annonces dynamiques.
4. Spécifiez un ou plusieurs critères pour diffuser les annonces dynamiques sur le Réseau de Recherche dans la campagne.

Créer la campagne

Pour configurer des ADR dans votre campagne, créez un Campaign avec advertising_channel_type défini sur AdvertisingChannelType.SEARCH. De plus, spécifiez le domaine du site Web (domain_name, sans http:// ni https://) et la langue (language_code) dans lesquels les ADR fonctionnent en définissant le champ dynamic_search_ads_setting de Campaign à l'aide de DynamicSearchAdsSetting. domain_name et language_code sont obligatoires. Vous pouvez également définir use_supplied_urls_only sur DynamicSearchAdsSetting (true limite le ciblage aux URL de flux de pages ADR uniquement, tandis que false utilise à la fois l'index Google de votre domaine et les URL de flux de pages).

L'exemple suivant crée une campagne 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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation de l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages des champs JSON
• Consultez la documentation de référence de l'API REST pour connaître le service et la méthode spécifiques.

Créer le groupe d'annonces

Pour utiliser les fonctionnalités des DSA, créez un AdGroup avec le champ type défini sur SEARCH_DYNAMIC_ADS. Ce type de groupe d'annonces applique les restrictions suivantes :

• Ce type de groupe d'annonces ne peut être ajouté qu'aux campagnes sur le Réseau de Recherche.
• Un DynamicSearchAdsSetting valide doit être défini au niveau de la campagne avant d'ajouter le groupe d'annonces. Sinon, l'API renvoie un AdGroupError avec CANNOT_ADD_ADGROUP_OF_TYPE_DSA_TO_CAMPAIGN_WITHOUT_DSA_SETTING.
• Les mots clés à inclure ne sont pas autorisés dans ce type de groupe d'annonces. Les cibles d'audience, les cibles d'annonces dynamiques (webpage) et les mots clés à exclure sont autorisés.
• Comme pour tous les groupes d'annonces, le champ type ne peut pas être modifié après la création.
• Seuls les formats d'annonces associés aux annonces dynamiques du Réseau de Recherche sont autorisés dans ce groupe d'annonces.

L'exemple de code suivant montre comment créer un groupe d'annonces 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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation de l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages des champs JSON
• Consultez la documentation de référence de l'API REST pour connaître le service et la méthode spécifiques.

Créer l'annonce dynamique du Réseau de Recherche

Pour créer le DSA, instanciez un objet ExpandedDynamicSearchAdInfo et définissez les champs suivants :

• Obligatoire : description
• Facultatif : description2

Le titre, l'URL à afficher et l'URL finale de l'annonce sont générés automatiquement au moment de la diffusion en fonction des informations spécifiques au domaine fournies par le DynamicSearchAdsSetting configuré au niveau de la campagne.

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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation de l'interface REST de l'API Google Ads et les pages de référence spécifiques aux méthodes. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages des champs JSON
• Consultez la documentation de référence de l'API REST pour connaître le service et la méthode spécifiques.

Étant donné que final_urls est calculé de manière dynamique par Google Ads, vous ne devez pas définir final_urls sur le Ad parent lorsque vous créez une annonce dynamique du Réseau de Recherche. Pour utiliser un logiciel de suivi des URL, vous pouvez configurer des modèles de suivi à l'aide du champ tracking_url_template dans l'objet parent Ad (Ad.tracking_url_template, et non ExpandedDynamicSearchAdInfo), ou au niveau AdGroup (comme indiqué dans l'extrait de groupe d'annonces précédent) ou Campaign. Lorsque vous spécifiez ce champ, incluez l'un des paramètres ValueTrack suivants afin que Google Ads puisse insérer l'URL finale correspondante :

Paramètre	Explication
{unescapedlpurl}	URL de page de destination non échappée : à utiliser lorsque vous ajoutez des paramètres de requête à la fin, par exemple : {unescapedlpurl}?dsa=true
{escapedlpurl}	URL de la page de destination échappée (encodée au format URL). À utiliser en cas de redirection via un tracker tiers, par exemple : https://tracking.example.com/?lp={escapedlpurl}
{lpurlpath}	Seuls le chemin d'accès et les paramètres de requête de l'URL calculée, par exemple : https://tracking.example.com/track/{lpurlpath}
{lpurl}	Encode ? et = de l'URL de la page de destination et se termine par la requête de recherche. S'il est placé tout au début du champ tracking_url_template, il est remplacé par la valeur {unescapedlpurl}, par exemple : https://tracking.example.com/redir.php?tracking=xyz&url={lpurl}

Par exemple, en Java, définissez tracking_url_template sur le compilateur Ad :

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

Spécifier les critères pour la DSA

Enfin, configurez les critères pour déclencher la diffusion des annonces dynamiques du Réseau de Recherche à l'aide du champ webpage de AdGroupCriterion (consultez l'exemple complet d'ajout d'annonces dynamiques du Réseau de Recherche). Définissez webpage sur un objet WebpageInfo avec un criterion_name obligatoire (obligatoire sur CREATE et interdit sur UPDATE) et jusqu'à trois conditions (combinés logiquement avec AND lors de l'évaluation ; une liste conditions vide cible toutes les pages du site Web de la campagne).

Ces conditions sont des instances WebpageConditionInfo qui spécifient ce qu'il faut filtrer ou faire correspondre dans le domaine configuré dans les paramètres de la campagne à l'aide d'un operand, d'un argument et d'un operator facultatif (EQUALS ou CONTAINS). Vous pouvez filtrer cinq types d'opérandes :

WebpageConditionOperand	Description
URL	Chaîne correspondant à une partie de l'URL d'une page.
CATEGORY	Chaîne avec une catégorie à comparer précisément.
PAGE_TITLE	Chaîne correspondant à un titre de page partiel.
PAGE_CONTENT	Chaîne correspondant au contenu d'une page indexée.
CUSTOM_LABEL	Chaîne correspondant à une condition de ciblage par étiquette personnalisée de page Web. Consultez Inclure des URL cibles à l'aide d'étiquettes personnalisées.

Par exemple, vous pouvez créer un critère de page Web qui cible les pages du chemin d'accès /children d'un site de vacances (condition URL) et qui contiennent également "Offre spéciale" dans le titre (condition PAGE_TITLE).

Découvrir les catégories de sites

Vous pouvez récupérer et filtrer la liste des objets DomainCategory que Google Ads identifie pour votre site en interrogeant la ressource domain_category dans GAQL.

La requête GAQL suivante récupère les catégories de domaine pour un site et une campagne spécifiques :

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

Exclure les cibles de pages Web

Vous pouvez également utiliser AdGroupCriterionService pour créer des critères webpage à exclure (en définissant negative = true sur AdGroupCriterion). Par exemple, vous pouvez exclure les pages avec un titre spécifique que vous gérez dans une campagne ou un groupe d'annonces distincts.

Autres critères

Les campagnes et les groupes d'annonces ADR ne sont pas limités aux critères de page Web. Vous pouvez les combiner avec d'autres types de critères pour affiner le ciblage. Toutefois, utilisez les critères supplémentaires avec discernement, car un ciblage trop restrictif peut réduire l'efficacité du ciblage automatique des ADR.