Cette page a été traduite par l'API Cloud Translation.

Taux d'optimisation et recommandations

Les recommandations peuvent améliorer vos campagnes de plusieurs manières:

Présenter de nouvelles fonctionnalités pertinentes
Tirez pleinement parti de votre budget grâce à des enchères, des mots clés et des annonces améliorés
Améliorez les performances et l'efficacité globales de vos campagnes

Pour augmenter les taux d'optimisation, vous pouvez utiliser RecommendationService pour récupérer des recommandations, puis les appliquer ou les ignorer en conséquence.

Taux d'optimisation

Vidéo: taux d'optimisation

Le taux d'optimisation est une estimation du potentiel de votre compte Google Ads tel que vous l'avez configuré. Il est disponible aux niveaux Customer et Campaign.

Le Customer.optimization_score_weight n'est disponible que pour les comptes non-administrateur et permet de calculer le taux d'optimisation global de plusieurs comptes. Récupérez le taux d'optimisation et la pondération du taux d'optimisation des comptes, puis multipliez-les (Customer.optimization_score * Customer.optimization_score_weight) pour calculer le taux d'optimisation global.

Des métriques liées à l'optimisation sont disponibles pour les rapports customer et campaign:

L'metrics.optimization_score_url fournit un lien profond dans le compte pour afficher des informations sur les recommandations associées dans l'UI Google Ads.
metrics.optimization_score_uplift indique l'augmentation du taux d'optimisation si toutes les recommandations associées étaient appliquées.

L'optimization_score_uplift est une estimation basée sur toutes les recommandations disponibles dans leur ensemble, et pas seulement sur la somme des scores d'augmentation de chaque recommandation.

Types de recommandation

L'API Google Ads est entièrement compatible avec les types de recommandations suivants:

RecommendationType	Description
`CAMPAIGN_BUDGET`	Corriger les campagnes limitées par leur budget
`KEYWORD`	Ajouter de nouveaux mots clés
`TEXT_AD`	Ajouter des suggestions d'annonces
`TARGET_CPA_OPT_IN`	Enchère avec CPA cible
`MAXIMIZE_CONVERSIONS_OPT_IN`	Définir des enchères avec la stratégie "Maximiser les conversions"
`ENHANCED_CPC_OPT_IN`	Enchère avec Optimiseur de CPC
`SEARCH_PARTNERS_OPT_IN`	Élargissez votre couverture grâce aux partenaires du Réseau de Recherche de Google
`MAXIMIZE_CLICKS_OPT_IN`	Enchère avec Maximiser les clics
`OPTIMIZE_AD_ROTATION`	Utiliser la rotation optimisée des annonces
`CALLOUT_EXTENSION`	Ajouter des extensions d'accroche à la campagne
`SITELINK_EXTENSION`	Ajouter des extensions Liens annexes à la campagne
`CALL_EXTENSION`	Ajouter des extensions d'appel à la campagne
`KEYWORD_MATCH_TYPE (deprecated)`	Modifier les types de correspondance des mots clés
`MOVE_UNUSED_BUDGET`	Réaffectez vos budgets inutilisés aux budgets limités
`TARGET_ROAS_OPT_IN`	Enchère avec ROAS cible
`FORECASTING_CAMPAIGN_BUDGET`	Corrigez les campagnes qui devraient être limitées par le budget à l'avenir
`RESPONSIVE_SEARCH_AD`	Ajouter une annonce responsive sur le Réseau de Recherche
`MARGINAL_ROI_CAMPAIGN_BUDGET`	Ajustez le budget de votre campagne pour augmenter votre ROI
`USE_BROAD_MATCH_KEYWORD`	Utilisez la requête large pour les campagnes basées sur les conversions avec enchères automatiques
`RESPONSIVE_SEARCH_AD_ASSET`	Ajouter des composants d'annonces responsives sur le Réseau de Recherche à une annonce
`UPGRADE_SMART_SHOPPING_CAMPAIGN_TO_PERFORMANCE_MAX`	Convertir une campagne Shopping intelligente en campagne Performance Max
`RESPONSIVE_SEARCH_AD_IMPROVE_AD_STRENGTH`	Améliorer l'efficacité d'une annonce responsive sur le Réseau de Recherche
`DISPLAY_EXPANSION_OPT_IN`	Mettre à jour une campagne pour utiliser l'expansion au Réseau Display
`UPGRADE_LOCAL_CAMPAIGN_TO_PERFORMANCE_MAX`	Convertir une ancienne campagne locale en campagne Performance Max
`RAISE_TARGET_CPA_BID_TOO_LOW`	Recommandation visant à augmenter le CPA cible lorsqu'il est trop faible et qu'il y a très peu ou pas de conversions.
`FORECASTING_SET_TARGET_ROAS`	Recommandation d'augmentation du budget avant un événement saisonnier prévu pour augmenter le trafic et modification de la stratégie d'enchères (de "Maximiser la valeur de conversion" à "ROAS cible").

Gérer les types non compatibles

Récupérer les recommandations

Vidéo: codage en direct

Comme la plupart des autres entités de l'API Google Ads, les objets Recommendation sont extraits à l'aide de GoogleAdsService.SearchStream avec une requête de langage de requête Google Ads.

Pour chaque type de recommandation, les détails de la recommandation sont fournis dans un champ recommendation spécifique avec un type spécifique:

RecommendationType	recommendation	Type
`CAMPAIGN_BUDGET`	`campaign_budget_recommendation`	`CampaignBudgetRecommendation`
`KEYWORD`	`keyword_recommendation`	`KeywordRecommendation`
`TEXT_AD`	`text_ad_recommendation`	`TextAdRecommendation`
`TARGET_CPA_OPT_IN`	`target_cpa_opt_in_recommendation`	`TargetCpaOptInRecommendation`
`MAXIMIZE_CONVERSIONS_OPT_IN`	`maximize_conversions_opt_in_recommendation`	`MaximizeConversionsOptInRecommendation`
`ENHANCED_CPC_OPT_IN`	`enhanced_cpc_opt_in_recommendation`	`EnhancedCpcOptInRecommendation`
`SEARCH_PARTNERS_OPT_IN`	`search_partners_opt_in_recommendation`	`SearchPartnersOptInRecommendation`
`MAXIMIZE_CLICKS_OPT_IN`	`maximize_clicks_opt_in_recommendation`	`MaximizeClicksOptInRecommendation`
`OPTIMIZE_AD_ROTATION`	`optimize_ad_rotation_recommendation`	`OptimizeAdRotationRecommendation`
`CALLOUT_EXTENSION`	`callout_extension_recommendation`	`CalloutExtensionRecommendation`
`SITELINK_EXTENSION`	`sitelink_extension_recommendation`	`SitelinkExtensionRecommendation`
`CALL_EXTENSION`	`call_extension_recommendation`	`CallExtensionRecommendation`
`KEYWORD_MATCH_TYPE` (obsolète)	`keyword_match_type_recommendation`	`KeywordMatchTypeRecommendation`
`MOVE_UNUSED_BUDGET`	`move_unused_budget_recommendation`	`MoveUnusedBudgetRecommendation`
`TARGET_ROAS_OPT_IN`	`target_roas_opt_in_recommendation`	`TargetRoasOptInRecommendation`
`FORECASTING_CAMPAIGN_BUDGET`	`forecasting_campaign_budget_recommendation`	`CampaignBudgetRecommendation`
`RESPONSIVE_SEARCH_AD`	`responsive_search_ad_recommendation`	`ResponsiveSearchAdRecommendation`
`MARGINAL_ROI_CAMPAIGN_BUDGET`	`marginal_roi_campaign_budget_recommendation`	`CampaignBudgetRecommendation`
`USE_BROAD_MATCH_KEYWORD`	`use_broad_match_keyword_recommendation`	`UseBroadMatchKeywordRecommendation`
`RESPONSIVE_SEARCH_AD_ASSET`	`responsive_search_ad_asset_recommendation`	`ResponsiveSearchAdAssetRecommendation`
`DISPLAY_EXPANSION_OPT_IN`	`display_expansion_opt_in_recommendation`	`DisplayExpansionOptInRecommendation`
`UPGRADE_LOCAL_CAMPAIGN_TO_PERFORMANCE_MAX`	`upgrade_local_campaign_to_performance_max_recommendation`	`UpgradeLocalCampaignToPerformanceMaxRecommendation`
`RAISE_TARGET_CPA_BID_TOO_LOW`	`raise_target_cpa_bid_too_low_recommendation`	`RaiseTargetCpaBidTooLowRecommendation`
`FORECASTING_SET_TARGET_ROAS`	`forecasting_set_target_roas_recommendation`	`ForecastingSetTargetRoasRecommendation`

Exemple de code

L'exemple de code suivant récupère toutes les recommandations de type TEXT_AD disponibles et ignorées à partir d'un compte et affiche certaines de leurs informations:

Java

private void runExample(GoogleAdsClient googleAdsClient, long customerId) {
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    String query =
        "SELECT recommendation.type, "
            + "recommendation.campaign, "
            + "recommendation.text_ad_recommendation "
            + "FROM recommendation "
            + "WHERE recommendation.type = TEXT_AD";

    // Creates a request that will retrieve all recommendations using pages of the
    // specified page size.
    SearchGoogleAdsRequest request =
        SearchGoogleAdsRequest.newBuilder()
            .setCustomerId(Long.toString(customerId))
            .setPageSize(PAGE_SIZE)
            .setQuery(query)
            .build();
    // Issues the search request.
    SearchPagedResponse searchPagedResponse = googleAdsServiceClient.search(request);

    // Iterates over all rows in all pages and prints the requested field values for the
    // recommendation in each row.
    for (GoogleAdsRow googleAdsRow : searchPagedResponse.iterateAll()) {
      Recommendation recommendation = googleAdsRow.getRecommendation();
      Ad recommendedAd = recommendation.getTextAdRecommendation().getAd();

      System.out.printf(
          "Recommendation ('%s') was found for campaign '%s':%n",
          recommendation.getResourceName(), recommendation.getCampaign());
      if (recommendedAd.hasExpandedTextAd()) {
        ExpandedTextAdInfo eta = recommendedAd.getExpandedTextAd();
        System.out.printf(
            "\tHeadline 1 = '%s'%n" + "\tHeadline 2 = '%s'%n" + "\tDescription = '%s'%n",
            eta.getHeadlinePart1(), eta.getHeadlinePart2(), eta.getDescription());
      }
      if (recommendedAd.getDisplayUrl() != null) {
        System.out.printf("\tDisplay URL = '%s'%n", recommendedAd.getDisplayUrl());
      }
      for (String url : recommendedAd.getFinalUrlsList()) {
        System.out.printf("\tFinal URL = '%s'%n", url);
      }
      for (String url : recommendedAd.getFinalMobileUrlsList()) {
        System.out.printf("\tFinal Mobile URL = '%s'%n", url);
      }
    }
  }
}GetTextAdRecommendations.java

C#

public void Run(GoogleAdsClient client, long customerId)
{
    // Get the GoogleAdsServiceClient .
    GoogleAdsServiceClient service = client.GetService(Services.V12.GoogleAdsService);

    string query =
        @"SELECT
        recommendation.type,
        recommendation.campaign,
        recommendation.text_ad_recommendation
    FROM
        recommendation
    WHERE
        recommendation.type = TEXT_AD";

    // Create a request that will retrieve all recommendations using pages of the
    // specified page size.
    SearchGoogleAdsRequest request = new SearchGoogleAdsRequest()
    {
        CustomerId = customerId.ToString(),
        PageSize = PAGE_SIZE,
        Query = query
    };

    try
    {
        // Issue the search request.
        PagedEnumerable<SearchGoogleAdsResponse, GoogleAdsRow> searchPagedResponse =
            service.Search(customerId.ToString(), query);

        // Iterates over all rows in all pages and prints the requested field values
        // for the recommendation in each row.
        foreach (GoogleAdsRow googleAdsRow in searchPagedResponse)
        {
            Recommendation recommendation = googleAdsRow.Recommendation;
            // ...
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}GetTextAdRecommendations.cs

PHP

public static function runExample(GoogleAdsClient $googleAdsClient, int $customerId)
{
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    // Creates a query that retrieves recommendations for text ads.
    $query = 'SELECT recommendation.type, recommendation.campaign, '
        . 'recommendation.text_ad_recommendation '
        . 'FROM recommendation '
        . 'WHERE recommendation.type = TEXT_AD';

    // Issues a search request by specifying page size.
    $response =
        $googleAdsServiceClient->search($customerId, $query, ['pageSize' => self::PAGE_SIZE]);

    // Iterates over all rows in all pages and prints the requested field values for
    // the recommendation in each row.
    foreach ($response->iterateAllElements() as $googleAdsRow) {
        /** @var GoogleAdsRow $googleAdsRow */
        $recommendation = $googleAdsRow->getRecommendation();
        printf(
            "Recommendation with resource name '%s' was found for campaign "
            . "with resource name '%s':%s",
            $recommendation->getResourceName(),
            $recommendation->getCampaign(),
            PHP_EOL
        );
        $recommendedAd = $recommendation->getTextAdRecommendation()->getAd();
        if (!is_null($recommendedAd->getExpandedTextAd())) {
            $recommendedExpandedTextAd = $recommendedAd->getExpandedTextAd();
            printf(
                "\tHeadline part 1 is '%s'.%s",
                $recommendedExpandedTextAd->getHeadlinePart1(),
                PHP_EOL
            );
            printf(
                "\tHeadline part 2 is '%s'.%s",
                $recommendedExpandedTextAd->getHeadlinePart2(),
                PHP_EOL
            );
            printf(
                "\tDescription is '%s'%s",
                $recommendedExpandedTextAd->getDescription(),
                PHP_EOL
            );
        }
        if (!is_null($recommendedAd->getDisplayUrl())) {
            printf("\tDisplay URL is '%s'.%s", $recommendedAd->getDisplayUrl(), PHP_EOL);
        }
        foreach ($recommendedAd->getFinalUrls() as $finalUrl) {
            /** @var string $finalUrl */
            printf("\tFinal URL is '%s'.%s", $finalUrl, PHP_EOL);
        }
        foreach ($recommendedAd->getFinalMobileUrls() as $finalMobileUrl) {
            /** @var string $finalMobileUrl */
            printf("\tFinal Mobile URL is '%s'.%s", $finalMobileUrl, PHP_EOL);
        }
    }
}GetTextAdRecommendations.php

Python

def main(client, customer_id):
    ga_service = client.get_service("GoogleAdsService")

    query = """
        SELECT
          recommendation.type,
          recommendation.campaign,
          recommendation.text_ad_recommendation
        FROM recommendation
        WHERE recommendation.type = TEXT_AD"""

    search_request = client.get_type("SearchGoogleAdsStreamRequest")
    search_request.customer_id = customer_id
    search_request.query = query
    stream = ga_service.search_stream(request=search_request)

    for batch in stream:
        for row in batch.results:
            recommendation = row.recommendation
            recommended_ad = recommendation.text_ad_recommendation.ad
            print(
                f'Recommendation ("{recommendation.resource_name}") '
                f'was found for campaign "{recommendation.campaign}".'
            )

            if recommended_ad.display_url:
                print(f'\tDisplay URL = "{recommended_ad.display_url}"')

            for url in recommended_ad.final_urls:
                print(f'\tFinal URL = "{url}"')

            for url in recommended_ad.final_mobile_urls:
                print(f'\tFinal Mobile URL = "{url}"')get_text_ad_recommendations.py

Ruby

def get_text_ad_recommendations(customer_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  ga_service = client.service.google_ads

  query = <<~QUERY
    SELECT recommendation.type, recommendation.campaign,
        recommendation.text_ad_recommendation
    FROM recommendation
    WHERE recommendation.type = TEXT_AD
  QUERY

  response = ga_service.search(
    customer_id: customer_id,
    query: query,
    page_size: PAGE_SIZE,
  )

  response.each do |row|
    recommendation = row.recommendation
    recommended_ad = recommendation.text_ad_recommendation.ad

    puts "Recommendation ('#{recommendation.resource_name}') was found for "\
        "campaign '#{recommendation.campaign}'."
    if recommended_ad.expanded_text_ad
      eta = recommended_ad.expanded_text_ad
      puts "\tHeadline 1 = '#{eta.headline_part1}'\n\tHeadline2 = '#{eta.headline_part2}'\n" +
          "\tDescription = '#{eta.description}'"
    end
    if recommended_ad.display_url
      puts "\tDisplay URL = '#{recommended_ad.display_url}'"
    end
    recommended_ad.final_urls.each do |url|
      puts "\tFinal Url = '#{url}'"
    end
    recommended_ad.final_mobile_urls.each do |url|
      puts "\tFinal Mobile Url = '#{url}'"
    end
  end
endget_text_ad_recommendations.rb

Perl

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

  # Creates the search query.
  my $search_query =
    "SELECT recommendation.type, recommendation.campaign, " .
    "recommendation.text_ad_recommendation " .
    "FROM recommendation WHERE recommendation.type = TEXT_AD";

  # Create a search Google Ads request that will retrieve all recommendations for
  # text ads using pages of the specified page size.
  my $search_request =
    Google::Ads::GoogleAds::V12::Services::GoogleAdsService::SearchGoogleAdsRequest
    ->new({
      customerId => $customer_id,
      query      => $search_query,
      pageSize   => PAGE_SIZE
    });

  # Get the GoogleAdsService.
  my $google_ads_service = $api_client->GoogleAdsService();

  my $iterator = Google::Ads::GoogleAds::Utils::SearchGoogleAdsIterator->new({
    service => $google_ads_service,
    request => $search_request
  });

  # Iterate over all rows in all pages and print the requested field values for
  # the recommendation in each row.
  while ($iterator->has_next) {
    my $google_ads_row = $iterator->next;
    my $recommendation = $google_ads_row->{recommendation};
    printf
      "Recommendation '%s' was found for campaign '%s':\n",
      $recommendation->{resourceName},
      $recommendation->{campaign};

    my $recommended_ad = $recommendation->{textAdRecommendation}{ad};
    if ($recommended_ad->{expandedTextAd}) {
      my $recommended_expanded_text_ad = $recommended_ad->{expandedTextAd};

      printf "\tHeadline part 1 is '%s'.\n" .
        "\tHeadline part 2 is '%s'.\n" . "\tDescription is '%s'.\n",
        $recommended_expanded_text_ad->{headlinePart1},
        $recommended_expanded_text_ad->{headlinePart2},
        $recommended_expanded_text_ad->{description};
    }

    if ($recommended_ad->{displayUrl}) {
      printf "\tDisplay URL is '%s'.\n", $recommended_ad->{displayUrl};
    }

    foreach my $final_url (@{$recommended_ad->{finalUrls}}) {
      printf "\tFinal URL is '%s'.\n", $final_url;
    }

    foreach my $final_mobile_url (@{$recommended_ad->{finalMobileUrls}}) {
      printf "\tFinal Mobile URL is '%s'.\n", $final_mobile_url;
    }
  }

  return 1;
}get_text_ad_recommendations.pl

Intervenez

Toute recommandation récupérée peut être appliquée ou ignorée.

Selon le type de recommandation, les recommandations peuvent changer quotidiennement ou même plusieurs fois par jour. Lorsque cela se produit, l'objet resource_name d'un objet de recommandation peut devenir obsolète une fois la recommandation récupérée.

Nous vous recommandons d'appliquer les recommandations peu de temps après leur récupération.

Appliquer les recommandations

Vidéo: Appliquer les recommandations

La définition de comptes pour l'application automatique des recommandations n'est pas disponible dans l'API Google Ads. Toutefois, vous pouvez mettre en œuvre un comportement similaire pour les types de recommandations entièrement compatibles avec l'API Google Ads. Pour en savoir plus, consultez l'exemple de code DetectAndApplyRecommendations.

Vous pouvez appliquer des recommandations actives ou ignorées à l'aide de la méthode ApplyRecommendation de RecommendationService.

Les types de recommandations peuvent comporter des paramètres obligatoires ou facultatifs. La plupart des recommandations sont fournies avec des valeurs recommandées qui sont utilisées par défaut. Consultez la page Détails des recommandations pour en savoir plus.

Utilisez le champ apply_parameters de ApplyRecommendationOperation pour appliquer des recommandations avec des valeurs de paramètres spécifiques. Chaque type de recommandation approprié possède son propre champ. Les types de recommandations manquants dans la table n'utilisent pas ces valeurs de paramètres.

RecommendationType	apply_parameters	Type
`CAMPAIGN_BUDGET`	`campaign_budget`	`CampaignBudgetParameters`
`KEYWORD`	`keyword`	`KeywordParameters`
`TEXT_AD`	`text_ad`	`TextAdParameters`
`TARGET_CPA_OPT_IN`	`target_cpa_opt_in`	`TargetCpaOptInParameters`
`CALLOUT_EXTENSION`	`callout_extension`	`CalloutExtensionParameters`
`SITELINK_EXTENSION`	`sitelink_extension`	`SitelinkExtensionParameters`
`CALL_EXTENSION`	`call_extension`	`CallExtensionParameters`
`MOVE_UNUSED_BUDGET`	`move_unused_budget`	`MoveUnusedBudgetParameters`
`TARGET_ROAS_OPT_IN`	`target_roas_opt_in`	`TargetRoasOptInParameters`
`FORECASTING_CAMPAIGN_BUDGET`	`campaign_budget`	`CampaignBudgetParameters`
`RESPONSIVE_SEARCH_AD`	`responsive_search_ad`	`ResponsiveSearchAdParameters`
`MARGINAL_ROI_CAMPAIGN_BUDGET`	`campaign_budget`	`CampaignBudgetParameters`
`USE_BROAD_MATCH_KEYWORD`	`use_broad_match_keyword`	`UseBroadMatchKeywordRecommendation`
`RESPONSIVE_SEARCH_AD_ASSET`	`responsive_search_ad_asset`	`ResponsiveSearchAdAssetParameters`

Exemple de code

L'exemple de code suivant montre comment appliquer une recommandation avec les paramètres d'application recommandés:

Java

private void runExample(
    GoogleAdsClient googleAdsClient, long customerId, String recommendationId) {
  String recommendationResourceName = ResourceNames.recommendation(customerId, recommendationId);

  ApplyRecommendationOperation.Builder operationBuilder =
      ApplyRecommendationOperation.newBuilder().setResourceName(recommendationResourceName);
  // Each recommendation types has optional parameters to override the recommended values.
  // This is an example to override a recommended ad when a TextAdRecommendation is applied.
  // Please read
  // https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation
  // for details.
  // Note that additional import statements are needed for this example to work. And also, please
  // replace INSERT_AD_ID_HERE with a valid ad ID below.
  //
  // Ad overrideAd = Ad.newBuilder().setId(Long.parseLong("INSERT_AD_ID_HERE")).build();
  // operationBuilder.setTextAd(TextAdParameters.newBuilder().
  //     setAd(overrideAd).build()).build();
  List<ApplyRecommendationOperation> operations = new ArrayList<>();
  operations.add(operationBuilder.build());

  try (RecommendationServiceClient recommendationServiceClient =
      googleAdsClient.getLatestVersion().createRecommendationServiceClient()) {
    ApplyRecommendationResponse response =
        recommendationServiceClient.applyRecommendation(Long.toString(customerId), operations);
    System.out.printf("Applied %d recommendation:%n", response.getResultsCount());
    for (ApplyRecommendationResult result : response.getResultsList()) {
      System.out.println(result.getResourceName());
    }
  }
}ApplyRecommendation.java

C#

public void Run(GoogleAdsClient client, long customerId, long recommendationId)
{
    // Get the RecommendationServiceClient.
    RecommendationServiceClient service = client.GetService(
        Services.V12.RecommendationService);

    ApplyRecommendationOperation operation = new ApplyRecommendationOperation()
    {
        ResourceName = ResourceNames.Recommendation(customerId, recommendationId),

        // Each recommendation types has optional parameters to override the recommended
        // values. For example, you can override a recommended ad when a
        // TextAdRecommendation is applied, as shown below.
        // Please read https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation
        // for details.
        // TextAd = new TextAdParameters() {
        //   Ad = new Ad() {
        //     Id = long.Parse("INSERT_AD_ID_HERE")
        //   }
        // }
    };

    try
    {
        ApplyRecommendationResponse response = service.ApplyRecommendation(
            customerId.ToString(), new ApplyRecommendationOperation[] {
                operation
            });
        Console.WriteLine($"Applied {0} recommendation(s):", response.Results.Count);
        foreach (ApplyRecommendationResult result in response.Results)
        {
            Console.WriteLine($"- {result.ResourceName}");
        }
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}ApplyRecommendation.cs

PHP

public static function runExample(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    string $recommendationId
) {
    $recommendationResourceName =
        ResourceNames::forRecommendation($customerId, $recommendationId);

    $applyRecommendationOperation = new ApplyRecommendationOperation();
    $applyRecommendationOperation->setResourceName($recommendationResourceName);

    // Each recommendation type has optional parameters to override the recommended values.
    // This is an example to override a recommended ad when a TextAdRecommendation is applied.
    // For details, please read
    // https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation.
    /*
    $overridingAd = new Ad([
        'id' => 'INSERT_AD_ID_AS_INTEGER_HERE'
    ]);
    $applyRecommendationOperation->setTextAd(new TextAdParameters(['ad' => $overridingAd]));
    */
    // Issues a mutate request to apply the recommendation.
    $recommendationServiceClient = $googleAdsClient->getRecommendationServiceClient();
    $response = $recommendationServiceClient->applyRecommendation(
        $customerId,
        [$applyRecommendationOperation]
    );
    /** @var Recommendation $appliedRecommendation */
    $appliedRecommendation = $response->getResults()[0];

    printf(
        "Applied recommendation with resource name: '%s'.%s",
        $appliedRecommendation->getResourceName(),
        PHP_EOL
    );
}ApplyRecommendation.php

Python

def main(client, customer_id, recommendation_id):
    recommendation_service = client.get_service("RecommendationService")

    apply_recommendation_operation = client.get_type(
        "ApplyRecommendationOperation"
    )

    apply_recommendation_operation.resource_name = (
        recommendation_service.recommendation_path(
            customer_id, recommendation_id
        )
    )

    # This is where we override the recommended ad when a TextAdRecommendation is applied.
    # override_ad = client.get_type("Ad")
    # override_ad.resource_name = "INSERT_AD_ID_HERE"
    # apply_recommendation_operation.text_ad.ad = override_ad

    recommendation_response = recommendation_service.apply_recommendation(
        customer_id=customer_id, operations=[apply_recommendation_operation]
    )

    print(
        "Applied recommendation with resource name: "
        f"'{recommendation_response.results[0].resource_name}'"
    )apply_recommendation.py

Ruby

def apply_recommendation(customer_id, recommendation_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  recommendation_resource =
      client.path.recommendation(customer_id, recommendation_id)
  apply_recommendation_operation = client.operation.apply_recommendation
  apply_recommendation_operation.resource_name = recommendation_resource

  # Each recommendation type has optional parameters to override the recommended
  # values. This is an example to override a recommended ad when a
  # TextAdRecommendation is applied.
  # For details, please read
  # https://developers.google.com/google-ads/api/reference/rpc/google.ads.google_ads.v1.services#google.ads.google_ads.v1.services.ApplyRecommendationOperation
  #
  # text_ad_parameters = client.resource.text_ad_parameters do |tap|
  #   tap.ad = client.resource.ad do |ad|
  #     ad.id = "INSERT_AD_ID_AS_INTEGER_HERE"
  #   end
  # end
  # apply_recommendation_operation.text_ad = text_ad_parameters

  # Issues a mutate request to apply the recommendation.
  recommendation_service = client.service.recommendation
  response = recommendation_service.apply_recommendation(
    customer_id: customer_id,
    operations: [apply_recommendation_operation],
  )
  applied_recommendation = response.results.first

  puts "Applied recommendation with resource name: '#{applied_recommendation.resource_name}'."
endapply_recommendation.rb

Perl

sub apply_recommendation {
  my ($api_client, $customer_id, $recommendation_id) = @_;

  my $recommendation_resource_name =
    Google::Ads::GoogleAds::V12::Utils::ResourceNames::recommendation(
    $customer_id, $recommendation_id);

  # Create an apply recommendation operation.
  my $apply_recommendation_operation =
    Google::Ads::GoogleAds::V12::Services::RecommendationService::ApplyRecommendationOperation
    ->new({
      resourceName => $recommendation_resource_name
    });

  # Each recommendation type has optional parameters to override the recommended values.
  # This is an example to override a recommended ad when a TextAdRecommendation is applied.
  # For details, please read
  # https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation.
  #
  # my $overriding_ad = Google::Ads::GoogleAds::V12::Resources::Ad->new({
  #   id => "INSERT_AD_ID_AS_INTEGER_HERE"
  # });
  # my $text_ad_parameters =
  #   Google::Ads::GoogleAds::V12::Services::RecommendationService::TextAdParameters
  #   ->new({ad => $overriding_ad});
  # $apply_recommendation_operation->{textAd} = $text_ad_parameters;

  # Apply the recommendation.
  my $apply_recommendation_response =
    $api_client->RecommendationService()->apply({
      customerId => $customer_id,
      operations => [$apply_recommendation_operation]});

  printf "Applied recommendation with resource name: '%s'.\n",
    $apply_recommendation_response->{results}[0]{resourceName};

  return 1;
}apply_recommendation.pl

Regardez ces vidéos pour en savoir plus

Appliquer les paramètres

En masse

Erreurs

Tests

Masquer les recommandations

Vidéo: Ignorer les recommandations

Vous pouvez ignorer les recommandations à l'aide de la méthode RecommendationService. La structure du code est semblable à l'application de recommandations, mais vous devez utiliser DismissRecommendationOperation et RecommendationService.DismissRecommendation à la place.