Taux d'optimisation et recommandations

Vidéo: présentation détaillée

Les recommandations peuvent améliorer vos campagnes de plusieurs façons:

  • Présenter de nouvelles fonctionnalités pertinentes
  • Exploitez pleinement votre budget en optimisant vos enchères, vos mots clés et vos annonces
  • Améliorez les performances globales et l'efficacité de vos campagnes

Pour augmenter les scores d'optimisation, vous pouvez utiliser RecommendationService pour récupérer des recommandations, puis les appliquer ou les ignorer en conséquence. À partir de la version 15 de l'API Google Ads, vous pouvez également vous abonner aux recommandations appliquées automatiquement à l'aide de RecommendationSubscriptionService.

Score d'optimisation

Vidéo: score d'optimisation

Le taux d'optimisation est une estimation des performances de votre compte Google Ads. 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 score d'optimisation et la pondération du score d'optimisation des comptes, puis multipliez-les (Customer.optimization_score * Customer.optimization_score_weight) pour calculer le score d'optimisation global.

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

  1. 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.
  2. L'metrics.optimization_score_uplift indique l'augmentation du score d'optimisation si toutes les recommandations associées sont appliquées. Il s'agit d'une estimation basée sur toutes les recommandations disponibles dans leur ensemble, et pas seulement sur la somme des scores d'amélioration pour chaque recommandation.

Pour regrouper et classer les recommandations renvoyées, vous pouvez segmenter ces deux métriques par type de recommandation en utilisant segments.recommendation_type dans votre requête.

Types de recommandation

Types de recommandations entièrement compatibles

RecommendationType Description
CAMPAIGN_BUDGET Corrigez 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érir avec un CPA cible
MAXIMIZE_CONVERSIONS_OPT_IN Enchérir avec la stratégie "Maximiser les conversions"
MAXIMIZE_CONVERSION_VALUE_OPT_IN Définir des enchères avec "Maximiser la valeur de conversion"
ENHANCED_CPC_OPT_IN Enchérir avec le CPC optimisé
MAXIMIZE_CLICKS_OPT_IN Enchérir avec la stratégie "Maximiser les clics"
OPTIMIZE_AD_ROTATION Utiliser la rotation optimisée des annonces
MOVE_UNUSED_BUDGET Réaffectez les budgets inutilisés aux budgets limités
TARGET_ROAS_OPT_IN Définir des enchères avec ROAS cible
FORECASTING_CAMPAIGN_BUDGET Corrigez les campagnes qui devraient être limitées par leur budget à l'avenir
RESPONSIVE_SEARCH_AD Ajouter une annonce responsive sur le Réseau de Recherche
MARGINAL_ROI_CAMPAIGN_BUDGET Ajuster le budget de la campagne pour augmenter le ROI
USE_BROAD_MATCH_KEYWORD Utilisez la requête large pour les campagnes basées sur les conversions avec les enchères automatiques
RESPONSIVE_SEARCH_AD_ASSET Ajouter des composants d'annonces responsives sur le Réseau de Recherche à une annonce
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
SEARCH_PARTNERS_OPT_IN Élargir votre couverture grâce aux partenaires du Réseau de Recherche de Google
CUSTOM_AUDIENCE_OPT_IN Créer une audience personnalisée
IMPROVE_DISCOVERY_AD_STRENGTH Améliorer l'efficacité des annonces dans les campagnes de génération de la demande
UPGRADE_SMART_SHOPPING_CAMPAIGN_TO_PERFORMANCE_MAX Migrer une campagne Shopping intelligente vers Performance Max
UPGRADE_LOCAL_CAMPAIGN_TO_PERFORMANCE_MAX Convertir une ancienne campagne locale en campagne Performance Max
SHOPPING_MIGRATE_REGULAR_SHOPPING_CAMPAIGN_OFFERS_TO_PERFORMANCE_MAX Migrez les offres ciblées par les campagnes Shopping standards vers les campagnes Performance Max existantes
MIGRATE_DYNAMIC_SEARCH_ADS_CAMPAIGN_TO_PERFORMANCE_MAX Migrer vos annonces dynamiques du Réseau de Recherche vers des campagnes Performance Max
PERFORMANCE_MAX_OPT_IN Créer des campagnes Performance Max dans votre compte
IMPROVE_PERFORMANCE_MAX_AD_STRENGTH Améliorer l'efficacité du groupe d'assets d'une campagne Performance Max en lui attribuant la note "Excellente"
PERFORMANCE_MAX_FINAL_URL_OPT_IN Activer l'extension d'URL finale pour vos campagnes Performance Max
RAISE_TARGET_CPA_BID_TOO_LOW 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 Augmenter le budget avant un événement saisonnier censé augmenter le trafic, et faire passer la stratégie d'enchères de la stratégie d'enchères "Maximiser la valeur de conversion" au ROAS cible
LEAD_FORM Ajouter des composants Formulaire pour prospects à une campagne
CALLOUT_ASSET Ajouter des composants Accroche au niveau de la campagne ou du client
SITELINK_ASSET Ajouter des composants Lien annexe au niveau de la campagne ou du client
CALL_ASSET Ajouter des composants Appel au niveau de la campagne ou du client
SHOPPING_ADD_AGE_GROUP Ajoutez l'attribut tranche d'âge aux offres rétrogradées en raison d'une tranche d'âge manquante.
SHOPPING_ADD_COLOR Ajouter une couleur aux offres rétrogradées en raison d'une couleur manquante
SHOPPING_ADD_GENDER Ajoutez un sexe aux offres qui sont rétrogradées en raison de l'absence d'un sexe
SHOPPING_ADD_GTIN Ajoutez un code GTIN (Global Trade Item Number) aux offres rétrogradées en raison d'un code GTIN manquant
SHOPPING_ADD_MORE_IDENTIFIERS Ajouter d'autres identifiants aux offres rétrogradées en raison d'identifiants manquants
SHOPPING_ADD_SIZE Ajoutez la taille aux offres rétrogradées en raison d'une taille manquante
SHOPPING_ADD_PRODUCTS_TO_CAMPAIGN Ajoutez des produits pour qu'une campagne soit diffusée
SHOPPING_FIX_DISAPPROVED_PRODUCTS Corriger les produits refusés
SHOPPING_TARGET_ALL_OFFERS Créer une campagne générique ciblant toutes les offres
SHOPPING_FIX_SUSPENDED_MERCHANT_CENTER_ACCOUNT Corrigez les problèmes de suspension de compte Merchant Center
SHOPPING_FIX_MERCHANT_CENTER_ACCOUNT_SUSPENSION_WARNING Corrigez les problèmes d'avertissement de suspension de compte Merchant Center
DYNAMIC_IMAGE_EXTENSION_OPT_IN Activer les extensions d'image dynamiques dans le compte
RAISE_TARGET_CPA Augmenter le CPA cible
LOWER_TARGET_ROAS de diminution du ROAS cible
FORECASTING_SET_TARGET_CPA Définissez un CPA cible pour les campagnes qui n'en ont pas spécifié avant un événement saisonnier susceptible d'augmenter le trafic.
SET_TARGET_CPA Définir un CPA cible pour les campagnes qui n'en ont pas spécifié
SET_TARGET_ROAS Définir un ROAS cible pour les campagnes qui n'en ont pas spécifié
REFRESH_CUSTOMER_MATCH_LIST Modifier une liste de clients qui n'a pas été mise à jour au cours des 90 derniers jours
IMPROVE_GOOGLE_TAG_COVERAGE Déployez la balise Google sur d'autres pages
CALLOUT_EXTENSION (obsolète) Obsolète. Utilisez plutôt CALLOUT_ASSET.
SITELINK_EXTENSION (obsolète) Obsolète. Utilisez plutôt SITELINK_ASSET.
CALL_EXTENSION (obsolète) Obsolète. Utilisez plutôt CALL_ASSET.
KEYWORD_MATCH_TYPE (obsolète) Obsolète. Utilisez plutôt USE_BROAD_MATCH_KEYWORD.

Regardez cette vidéo pour en savoir plus

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 en langage de requête Google Ads.

Pour chaque type de recommandation, les détails sont fournis dans un champ spécifique à la recommandation. Par exemple, les détails des recommandations CAMPAIGN_BUDGET se trouvent dans le champ campaign_budget_recommendation et sont encapsulés dans un objet CampaignBudgetRecommendation.

Recherchez tous les champs spécifiques aux recommandations dans le champ d'union recommendation.

Impact des recommandations

Certains types de recommandations renseignent le champ impact de la recommandation. RecommendationImpact contient une estimation de l'impact de l'application de la recommandation sur les performances du compte. Les métriques de recommandation suivantes sont disponibles dans les champs impact.base_metrics et impact.potential_metrics:

  • impressions

  • clicks

  • cost_micros

  • conversions

  • all_conversions (disponible à partir de la version 16 de l'API Google Ads)

  • video_views

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 imprime 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);
      }
    }
  }
}
      

C#

public void Run(GoogleAdsClient client, long customerId)
{
    // Get the GoogleAdsServiceClient .
    GoogleAdsServiceClient service = client.GetService(Services.V15.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;
    }
}
      

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(
        SearchGoogleAdsRequest::build($customerId, $query)->setPageSize(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);
        }
    }
}
      

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}"')
      

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
end
      

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::V15::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;
}
      

Intervenez

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

Selon le type de recommandation, les recommandations peuvent changer quotidiennement, voire plusieurs fois par jour. Dans ce cas, le resource_name d'un objet de recommandation peut devenir obsolète une fois la recommandation récupérée.

Une bonne pratique consiste à appliquer les recommandations peu de temps après leur récupération.

Appliquer les recommandations

Vidéo: appliquer les recommandations

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 s'accompagnent de valeurs recommandées, qui sont utilisées par défaut.

Il n'est pas possible de définir des comptes pour l'application automatique des recommandations pour tous les types de recommandations. Toutefois, vous pouvez implémenter 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.

Utilisez le champ d'union 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 recommandation non répertoriés dans le champ apply_parameters n'utilisent pas ces valeurs de paramètres.

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

C#

public void Run(GoogleAdsClient client, long customerId, long recommendationId)
{
    // Get the RecommendationServiceClient.
    RecommendationServiceClient service = client.GetService(
        Services.V15.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;
    }
}
      

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(
        ApplyRecommendationRequest::build($customerId, [$applyRecommendationOperation])
    );
    /** @var Recommendation $appliedRecommendation */
    $appliedRecommendation = $response->getResults()[0];

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

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}'"
    )
      

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}'."
end
      

Perl

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

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

  # Create an apply recommendation operation.
  my $apply_recommendation_operation =
    Google::Ads::GoogleAds::V15::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::V15::Resources::Ad->new({
  #   id => "INSERT_AD_ID_AS_INTEGER_HERE"
  # });
  # my $text_ad_parameters =
  #   Google::Ads::GoogleAds::V15::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;
}
      

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, si ce n'est que vous utilisez DismissRecommendationOperation et RecommendationService.DismissRecommendation à la place.

Regardez ces vidéos pour en savoir plus

En masse

Erreurs

Tests

Appliquez automatiquement les recommandations

À partir de la version 15 de l'API Google Ads, vous pouvez utiliser RecommendationSubscriptionService pour appliquer automatiquement des recommandations d'un type spécifique.

Pour vous abonner à un type de recommandation particulier, créez un objet RecommendationSubscription, définissez le champ type sur l'un des types de recommandations compatibles, puis définissez le champ status sur ENABLED.

Types de recommandations compatibles avec les abonnements

  • ENHANCED_CPC_OPT_IN
  • KEYWORD
  • KEYWORD_MATCH_TYPE
  • LOWER_TARGET_ROAS
  • MAXIMIZE_CLICKS_OPT_IN
  • OPTIMIZE_AD_ROTATION
  • RAISE_TARGET_CPA
  • RESPONSIVE_SEARCH_AD
  • RESPONSIVE_SEARCH_AD_IMPROVE_AD_STRENGTH
  • SEARCH_PARTNERS_OPT_IN
  • SEARCH_PLUS_OPT_IN
  • SET_TARGET_CPA
  • SET_TARGET_ROAS
  • TARGET_CPA_OPT_IN
  • TARGET_ROAS_OPT_IN
  • USE_BROAD_MATCH_KEYWORD

Récupérer les abonnements

Pour obtenir des informations sur les abonnements aux recommandations d'un compte, interrogez la ressource recommendation_subscription.

Pour afficher les modifications qui ont été appliquées automatiquement, interrogez la ressource change_event en filtrant change_client_type sur GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Recommandations lorsque vous créez une campagne

À partir de la version 16 de l'API Google Ads, vous pouvez utiliser RecommendationService.GenerateRecommendationsRequest afin de générer des recommandations lorsque vous créez une campagne, pour un ensemble donné de types de recommandations.

GenerateRecommendations accepte comme entrée un numéro client, un type de canal publicitaire qui doit être SEARCH ou PERFORMANCE_MAX, une liste de types de recommandations à générer et divers points de données qui dépendent des types spécifiés. Elle génère une liste d'objets Recommendation en fonction des données que vous fournissez. Si les données sont insuffisantes pour générer une recommandation pour l'élément recommendation_types demandé, ou si la campagne présente déjà l'état recommandé, l'ensemble de résultats ne contiendra aucune recommandation pour ce type. Assurez-vous que votre application gère le cas où aucune recommandation n'est renvoyée pour les types de recommandations demandés.

Le tableau suivant décrit les types de recommandations compatibles avec GenerateRecommendations et les champs que vous devez fournir pour recevoir des recommandations pour ce type. Il est recommandé d'envoyer la requête GenerateRecommendations après avoir collecté toutes les informations liées aux types de recommandations demandés. Pour en savoir plus sur les champs obligatoires et facultatifs, y compris les champs imbriqués, consultez la documentation de référence.

RecommendationType Champs obligatoires Champs facultatifs
KEYWORD
  • seed_info
  • ad_group_info
MAXIMIZE_CLICKS_OPT_IN
  • conversion_tracking_status
  • bidding_info
MAXIMIZE_CONVERSIONS_OPT_IN
  • conversion_tracking_status
  • bidding_info
MAXIMIZE_CONVERSION_VALUE_OPT_IN
  • conversion_tracking_status
  • bidding_info
SET_TARGET_CPA
  • conversion_tracking_status
  • bidding_info
SET_TARGET_ROAS
  • conversion_tracking_status
  • bidding_info
SITELINK_ASSET
Remarque: L'objet SitelinkAssetRecommendation renvoyé contiendra des listes vides. Si la réponse GenerateRecommendations contient un élément SitelinkAssetRecommendation, il peut être considéré comme un signal visant à ajouter au moins un composant Lien annexe à la campagne.
  • campaign_sitelink_count
TARGET_CPA_OPT_IN
  • conversion_tracking_status
  • bidding_info
TARGET_ROAS_OPT_IN
  • conversion_tracking_status
  • bidding_info

Exemple de flux d'utilisation

Supposons que votre entreprise soit une agence publicitaire proposant un flux de travail de création de campagne aux utilisateurs, et que vous souhaitiez leur proposer des suggestions au cours de ce processus. GenerateRecommendationsRequest vous permet de générer des recommandations à la demande et de les intégrer dans l'interface utilisateur de création de vos campagnes.

Le flux d'utilisation peut se présenter comme suit:

  1. Un utilisateur accède à votre application pour créer une campagne Performance Max.

  2. L'utilisateur fournit des informations initiales dans le cadre du processus de création de la campagne. Par exemple, elles fournissent des informations pour créer un seul élément SitelinkAsset et sélectionnent TARGET_SPEND comme stratégie d'enchères intelligentes.

  3. Vous envoyez un objet GenerateRecommendationsRequest qui définit les champs suivants:

    • campaign_sitelink_count : défini sur 1, qui correspond au nombre de composants Lien annexe dans la campagne en cours.

    • bidding_info : définissez le champ bidding_strategy_type imbriqué sur TARGET_SPEND.

    • conversion_tracking_status: défini sur ConversionTrackingStatus de ce client. Pour savoir comment récupérer ce champ, consultez le guide Premiers pas sur la gestion des conversions.

    • recommendation_types : défini sur [SITELINK_ASSET, MAXIMIZE_CLICKS_OPT_IN].

    • advertising_channel_type : défini sur PERFORMANCE_MAX.

    • customer_id: défini sur l'ID du client créant la campagne.

  4. Vous pouvez utiliser les recommandations dans GenerateRecommendationsResponse (ici, un SitelinkAssetRecommendation et un MaximizeClicksOptInRecommendation) et les suggérer à l'utilisateur en les affichant dans l'interface de création de campagne. Si l'utilisateur accepte une suggestion, vous pouvez ensuite l'intégrer dans la demande de création de campagne une fois qu'il a terminé le processus de construction de la campagne.