Taux d'optimisation et recommandations

ondemand_video Vidéo: Présentation détaillée

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

• Proposer de nouvelles fonctionnalités pertinentes
• Exploiter au mieux votre budget en optimisant vos enchères, vos mots clés et vos annonces
• Améliorer les performances globales et l'efficacité de vos campagnes

Pour augmenter votre score d'optimisation, vous pouvez utiliser RecommendationService pour récupérer des recommandations, puis les appliquer ou les ignorer en conséquence. Vous pouvez également vous abonner pour appliquer automatiquement les recommandations à l'aide de RecommendationSubscriptionService.

Score d'optimisation

ondemand_video Vidéo: score d'optimisation

Le score d'optimisation est une estimation des performances potentielles de votre compte Google Ads. Il est disponible aux niveaux Customer et Campaign.

Customer.optimization_score_weight n'est disponible que pour les comptes autres que les comptes administrateur. Il permet de calculer le score 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. metrics.optimization_score_url fournit un lien profond vers le compte pour afficher des informations sur les recommandations associées dans l'UI Google Ads.
2. metrics.optimization_score_uplift indique l'augmentation du score d'optimisation si vous appliquez toutes les recommandations associées. Il s'agit d'une estimation basée sur l'ensemble des recommandations disponibles, et non uniquement sur la somme des scores d'amélioration pour chaque recommandation.

Pour regrouper et trier les recommandations renvoyées, vous pouvez segmenter ces deux métriques par type de recommandation à l'aide de segments.recommendation_type dans votre requête.

Types de recommandation

Récupérer des recommandations

ondemand_video Vidéo: codage en direct

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

Pour chaque type de recommandation, des informations sont fournies 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 sur les performances du compte suite à l'application de la recommandation. 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

• video_views

Exemple de code

L'exemple de code suivant récupère toutes les recommandations disponibles et ignorées de type KEYWORD à partir d'un compte, puis imprime certains de leurs détails:

try (GoogleAdsServiceClient googleAdsServiceClient =
        googleAdsClient.getLatestVersion().createGoogleAdsServiceClient();
    RecommendationServiceClient recommendationServiceClient =
        googleAdsClient.getLatestVersion().createRecommendationServiceClient()) {
  // Creates a query that retrieves keyword recommendations.
  String query =
      "SELECT recommendation.resource_name, "
          + "  recommendation.campaign, "
          + "  recommendation.keyword_recommendation "
          + "FROM recommendation "
          + "WHERE recommendation.type = KEYWORD";
  // Constructs the SearchGoogleAdsStreamRequest.
  SearchGoogleAdsStreamRequest request =
      SearchGoogleAdsStreamRequest.newBuilder()
          .setCustomerId(Long.toString(customerId))
          .setQuery(query)
          .build();

  // Issues the search stream request to detect keyword recommendations that exist for the
  // customer account.
  ServerStream<SearchGoogleAdsStreamResponse> stream =
      googleAdsServiceClient.searchStreamCallable().call(request);

  // Creates apply operations for all the recommendations found.
  List<ApplyRecommendationOperation> applyRecommendationOperations = new ArrayList<>();
  for (SearchGoogleAdsStreamResponse response : stream) {
    for (GoogleAdsRow googleAdsRow : response.getResultsList()) {
      Recommendation recommendation = googleAdsRow.getRecommendation();
      System.out.printf(
          "Keyword recommendation '%s' was found for campaign '%s'%n",
          recommendation.getResourceName(), recommendation.getCampaign());
      KeywordInfo keyword = recommendation.getKeywordRecommendation().getKeyword();
      System.out.printf("\tKeyword = '%s'%n", keyword.getText());
      System.out.printf("\tMatch type = '%s'%n", keyword.getMatchType());

      // Creates an ApplyRecommendationOperation that will apply this recommendation, and adds
      // it to the list of operations.
      applyRecommendationOperations.add(buildRecommendationOperation(recommendation));
    }
  }
DetectAndApplyRecommendations.java
      

// Get the GoogleAdsServiceClient.
GoogleAdsServiceClient googleAdsService = client.GetService(
    Services.V18.GoogleAdsService);

// Creates a query that retrieves keyword recommendations.
string query = "SELECT recommendation.resource_name, " +
    "recommendation.campaign, recommendation.keyword_recommendation " +
    "FROM recommendation WHERE " +
    $"recommendation.type = KEYWORD";

List<ApplyRecommendationOperation> operations =
    new List<ApplyRecommendationOperation>();

try
{
    // Issue a search request.
    googleAdsService.SearchStream(customerId.ToString(), query,
        delegate (SearchGoogleAdsStreamResponse resp)
        {
            Console.WriteLine($"Found {resp.Results.Count} recommendations.");
            foreach (GoogleAdsRow googleAdsRow in resp.Results)
            {
                Recommendation recommendation = googleAdsRow.Recommendation;
                Console.WriteLine("Keyword recommendation " +
                    $"{recommendation.ResourceName} was found for campaign " +
                    $"{recommendation.Campaign}.");

                if (recommendation.KeywordRecommendation != null)
                {
                    KeywordInfo keyword =
                        recommendation.KeywordRecommendation.Keyword;
                    Console.WriteLine($"Keyword = {keyword.Text}, type = " +
                        "{keyword.MatchType}");
                }

                operations.Add(
                    BuildApplyRecommendationOperation(recommendation.ResourceName)
                );
            }
        }
    );
}
catch (GoogleAdsException e)
{
    Console.WriteLine("Failure:");
    Console.WriteLine($"Message: {e.Message}");
    Console.WriteLine($"Failure: {e.Failure}");
    Console.WriteLine($"Request ID: {e.RequestId}");
    throw;
}
DetectAndApplyRecommendations.cs
      

$googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
// Creates a query that retrieves keyword recommendations.
$query = 'SELECT recommendation.resource_name, recommendation.campaign, '
    . 'recommendation.keyword_recommendation '
    . 'FROM recommendation '
    . 'WHERE recommendation.type = KEYWORD ';
// Issues a search request to detect keyword recommendations that exist for the
// customer account.
$response =
    $googleAdsServiceClient->search(SearchGoogleAdsRequest::build($customerId, $query));

$operations = [];
// 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(
        "Keyword recommendation with resource name '%s' was found for campaign "
        . "with resource name '%s':%s",
        $recommendation->getResourceName(),
        $recommendation->getCampaign(),
        PHP_EOL
    );
    if (!is_null($recommendation->getKeywordRecommendation())) {
        $keyword = $recommendation->getKeywordRecommendation()->getKeyword();
        printf(
            "\tKeyword = '%s'%s\ttype = '%s'%s",
            $keyword->getText(),
            PHP_EOL,
            KeywordMatchType::name($keyword->getMatchType()),
            PHP_EOL
        );
    }
    // Creates an ApplyRecommendationOperation that will be used to apply this
    // recommendation, and adds it to the list of operations.
    $operations[] = self::buildRecommendationOperation($recommendation->getResourceName());
}
DetectAndApplyRecommendations.php
      

googleads_service = client.get_service("GoogleAdsService")
query = f"""
    SELECT
      recommendation.campaign,
      recommendation.keyword_recommendation
    FROM recommendation
    WHERE
      recommendation.type = KEYWORD"""

# Detects keyword recommendations that exist for the customer account.
response = googleads_service.search(customer_id=customer_id, query=query)

operations = []
for row in response.results:
    recommendation = row.recommendation
    print(
        f"Keyword recommendation ('{recommendation.resource_name}') "
        f"was found for campaign '{recommendation.campaign}."
    )

    keyword = recommendation.keyword_recommendation.keyword
    print(
        f"\tKeyword = '{keyword.text}'\n" f"\tType = '{keyword.match_type}'"
    )

    # Create an ApplyRecommendationOperation that will be used to apply
    # this recommendation, and add it to the list of operations.
    operations.append(
        build_recommendation_operation(client, recommendation.resource_name)
    )
detect_and_apply_recommendations.py
      

query = <<~QUERY
  SELECT recommendation.resource_name, recommendation.campaign,
      recommendation.keyword_recommendation
  FROM recommendation
  WHERE recommendation.type = KEYWORD
QUERY

google_ads_service = client.service.google_ads

response = google_ads_service.search(
  customer_id: customer_id,
  query: query,
)

operations = response.each do |row|
  recommendation = row.recommendation

  puts "Keyword recommendation ('#{recommendation.resource_name}') was found for "\
    "campaign '#{recommendation.campaign}'."

  if recommendation.keyword_recommendation
    keyword = recommendation.keyword_recommendation.keyword
    puts "\tKeyword = '#{keyword.text}'"
    puts "\ttype = '#{keyword.match_type}'"
  end

  build_recommendation_operation(client, recommendation.resource_name)
end
detect_and_apply_recommendations.rb
      

# Create the search query.
my $search_query =
  "SELECT recommendation.resource_name, " .
  "recommendation.campaign, recommendation.keyword_recommendation " .
  "FROM recommendation " .
  "WHERE recommendation.type = KEYWORD";

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

my $search_stream_handler =
  Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
    service => $google_ads_service,
    request => {
      customerId => $customer_id,
      query      => $search_query
    }});

# Create apply operations for all the recommendations found.
my $apply_recommendation_operations = ();
$search_stream_handler->process_contents(
  sub {
    my $google_ads_row = shift;
    my $recommendation = $google_ads_row->{recommendation};
    printf "Keyword recommendation '%s' was found for campaign '%s'.\n",
      $recommendation->{resourceName}, $recommendation->{campaign};
    my $keyword = $recommendation->{keywordRecommendation}{keyword};
    printf "\tKeyword = '%s'\n",    $keyword->{text};
    printf "\tMatch type = '%s'\n", $keyword->{matchType};
    # Creates an ApplyRecommendationOperation that will apply this recommendation, and adds
    # it to the list of operations.
    push @$apply_recommendation_operations,
      build_recommendation_operation($recommendation);
  });
detect_and_apply_recommendations.pl
      

Intervenir

Vous pouvez appliquer ou ignorer toutes les recommandations récupérées.

Selon le type de recommandation, elles peuvent changer quotidiennement, voire plusieurs fois par jour. Dans ce cas, l'resource_name d'un objet de recommandation peut devenir obsolète après la récupération de la recommandation.

Il est recommandé de prendre des mesures en fonction des recommandations peu de temps après leur récupération.

Appliquer les recommandations

ondemand_video 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 sont accompagnées de valeurs recommandées qui sont utilisées par défaut.

L'option permettant d'appliquer automatiquement les recommandations n'est pas disponible 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ètre spécifiques. Chaque type de recommandation approprié dispose de son propre champ. Tout type de recommandation non listé dans le champ apply_parameters n'utilise pas ces valeurs de paramètre.

Exemple de code

Le code suivant montre comment créer ApplyRecommendationOperation et comment remplacer les valeurs recommandées si vous souhaitez les remplacer par les vôtres.

/** Creates and returns an ApplyRecommendationOperation to apply the given recommendation. */
private ApplyRecommendationOperation buildRecommendationOperation(Recommendation recommendation) {
  // If you have a recommendation ID instead of a resource name, you can create a resource name
  // like this:
  // String resourceName = ResourceNames.recommendation(customerId, recommendationId);

  // Creates a builder to construct the operation.
  Builder operationBuilder = ApplyRecommendationOperation.newBuilder();

  // Each recommendation type has optional parameters to override the recommended values. Below is
  // an example showing how to override a recommended ad when a TextAdRecommendation is applied.
  // operationBuilder.getTextAdBuilder().getAdBuilder().setResourceName("INSERT_AD_RESOURCE_NAME");

  // Sets the operation's resource name to the resource name of the recommendation to apply.
  operationBuilder.setResourceName(recommendation.getResourceName());
  return operationBuilder.build();
}
DetectAndApplyRecommendations.java
      

private ApplyRecommendationOperation BuildApplyRecommendationOperation(
    string recommendationResourceName
)
{
    // If you have a recommendation_id instead of the resource_name you can create a
    // resource name from it like this:
    // string recommendationResourceName =
    //    ResourceNames.Recommendation(customerId, recommendationId)

    // 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.
    /*
    Ad overridingAd = new Ad()
    {
        Id = "INSERT_AD_ID_AS_LONG_HERE"
    };
    applyRecommendationOperation.TextAd = new TextAdParameters()
    {
        Ad = overridingAd
    };
    */

    ApplyRecommendationOperation applyRecommendationOperation =
    new ApplyRecommendationOperation()
    {
        ResourceName = recommendationResourceName
    };

    return applyRecommendationOperation;
}
DetectAndApplyRecommendations.cs
      

private static function buildRecommendationOperation(
    string $recommendationResourceName
): ApplyRecommendationOperation {
    // If you have a recommendation_id instead of the resource name, you can create a resource
    // name from it like this:
    /*
    $recommendationResourceName =
        ResourceNames::forRecommendation($customerId, $recommendationId);
    */

    // 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.
    $applyRecommendationOperation = new ApplyRecommendationOperation();
    $applyRecommendationOperation->setResourceName($recommendationResourceName);
    return $applyRecommendationOperation;
}
DetectAndApplyRecommendations.php
      

def build_recommendation_operation(client, recommendation):
    """Creates a ApplyRecommendationOperation to apply the given recommendation.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        recommendation: a resource name for the recommendation to be applied.
    """
    # If you have a recommendation ID instead of a resource name, you can create
    # a resource name like this:
    #
    # googleads_service = client.get_service("GoogleAdsService")
    # resource_name = googleads_service.recommendation_path(
    #   customer_id, recommendation.id
    # )

    operation = client.get_type("ApplyRecommendationOperation")

    # Each recommendation type has optional parameters to override the
    # recommended values. Below is an example showing how to override a
    # recommended ad when a TextAdRecommendation is applied.
    #
    # operation.text_ad.ad.resource_name = "INSERT_AD_RESOURCE_NAME"
    #
    # For more details, see:
    # https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation#apply_parameters

    operation.resource_name = recommendation
    return operation
detect_and_apply_recommendations.py
      

def build_recommendation_operation(client, recommendation)
  # If you have a recommendation_id instead of the resource_name
  # you can create a resource name from it like this:
  # recommendation_resource =
  #    client.path.recommendation(customer_id, recommendation_id)

  operations = client.operation.apply_recommendation
  operations.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.
  #
  # 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
  # operation.text_ad = text_ad_parameters
  #
  # For more details, see:
  # https://developers.google.com/google-ads/api/reference/rpc/latest/ApplyRecommendationOperation#apply_parameters

  return operation
end
detect_and_apply_recommendations.rb
      

sub build_recommendation_operation {
  my ($recommendation) = @_;

  # If you have a recommendation ID instead of a resource name, you can create a resource
  # name like this:
  # my $recommendation_resource_name =
  #   Google::Ads::GoogleAds::V18::Utils::ResourceNames::recommendation(
  #   $customer_id, $recommendation_id);

  # Each recommendation type has optional parameters to override the recommended values.
  # Below is an example showing how to override a recommended ad when a TextAdRecommendation
  # is applied.
  # my $overriding_ad = Google::Ads::GoogleAds::V18::Resources::Ad->new({
  #   id => "INSERT_AD_ID_AS_INTEGER_HERE"
  # });
  # my $text_ad_parameters =
  #   Google::Ads::GoogleAds::V18::Services::RecommendationService::TextAdParameters
  #   ->new({ad => $overriding_ad});
  # $apply_recommendation_operation->{textAd} = $text_ad_parameters;

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

  return $apply_recommendation_operation;
}
detect_and_apply_recommendations.pl
      

L'exemple suivant appelle ApplyRecommendation, en envoyant les opérations d'application des recommandations créées dans le code précédent.

// Issues a mutate request to apply the recommendations.
ApplyRecommendationResponse applyRecommendationsResponse =
    recommendationServiceClient.applyRecommendation(
        Long.toString(customerId), applyRecommendationOperations);
for (ApplyRecommendationResult applyRecommendationResult :
    applyRecommendationsResponse.getResultsList()) {
  System.out.printf(
      "Applied recommendation with resource name: '%s'.%n",
      applyRecommendationResult.getResourceName());
}
DetectAndApplyRecommendations.java
      

private void ApplyRecommendation(GoogleAdsClient client, long customerId,
    List<ApplyRecommendationOperation> operations)
{
    // Get the RecommendationServiceClient.
    RecommendationServiceClient recommendationService = client.GetService(
        Services.V18.RecommendationService);

    ApplyRecommendationRequest applyRecommendationRequest = new ApplyRecommendationRequest()
    {
        CustomerId = customerId.ToString(),
    };

    applyRecommendationRequest.Operations.AddRange(operations);

    ApplyRecommendationResponse response =
        recommendationService.ApplyRecommendation(applyRecommendationRequest);
    foreach (ApplyRecommendationResult result in response.Results)
    {
        Console.WriteLine("Applied a recommendation with resource name: " +
            result.ResourceName);
    }
}
DetectAndApplyRecommendations.cs
      

private static function applyRecommendations(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $operations
): void {
    // Issues a mutate request to apply the recommendations.
    $recommendationServiceClient = $googleAdsClient->getRecommendationServiceClient();
    $response = $recommendationServiceClient->applyRecommendation(
        ApplyRecommendationRequest::build($customerId, $operations)
    );
    foreach ($response->getResults() as $appliedRecommendation) {
        /** @var Recommendation $appliedRecommendation */
        printf(
            "Applied a recommendation with resource name: '%s'.%s",
            $appliedRecommendation->getResourceName(),
            PHP_EOL
        );
    }
}
DetectAndApplyRecommendations.php
      

def apply_recommendations(client, customer_id, operations):
    """Applies a batch of recommendations.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        operations: a list of ApplyRecommendationOperation messages.
    """
    # Issues a mutate request to apply the recommendations.
    recommendation_service = client.get_service("RecommendationService")
    response = recommendation_service.apply_recommendation(
        customer_id=customer_id, operations=operations
    )

    for result in response.results:
        print(
            "Applied a recommendation with resource name: "
            f"'{result[0].resource_name}'."
        )
detect_and_apply_recommendations.py
      

def apply_recommendations(client, customer_id, operations)
  # Issues a mutate request to apply the recommendation.
  recommendation_service = client.service.recommendation

  response = recommendation_service.apply_recommendation(
    customer_id: customer_id,
    operations: [operations],
  )

  response.results.each do |applied_recommendation|
    puts "Applied recommendation with resource name: '#{applied_recommendation.resource_name}'."
  end
end
detect_and_apply_recommendations.rb
      

# Issue a mutate request to apply the recommendations.
my $apply_recommendation_response =
  $api_client->RecommendationService()->apply({
    customerId => $customer_id,
    operations => $apply_recommendation_operations
  });

foreach my $result (@{$apply_recommendation_response->{results}}) {
  printf "Applied recommendation with resource name: '%s'.\n",
    $result->{resourceName};
}
detect_and_apply_recommendations.pl
      

Masquer les recommandations

ondemand_video Vidéo: Ignorer les recommandations

Vous pouvez ignorer les recommandations avec RecommendationService. La structure de code est semblable à celle de l'application des recommandations, mais vous utilisez DismissRecommendationOperation et RecommendationService.DismissRecommendation à la place.

Appliquez automatiquement les recommandations

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 recommandation acceptés, puis définissez le champ status sur ENABLED.

Récupérer des abonnements

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

Pour afficher les modifications appliquées automatiquement, interrogez la ressource change_event, en filtrant change_event.client_type sur GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Recommandations lors de la création de campagnes

Vous pouvez utiliser RecommendationService.GenerateRecommendationsRequest pour générer des recommandations lors de la création d'une campagne, pour un ensemble donné de types de recommandations.

GenerateRecommendations accepte comme entrée un ID 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 en fonction des types spécifiés. Elle renvoie une liste d'objets Recommendation en fonction des données que vous fournissez. Si les données ne sont pas suffisantes pour générer une recommandation pour le recommendation_types demandé ou si la campagne est déjà dans l'état "Recommandée", l'ensemble de résultats ne contient pas de 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 de 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.

Exemple de parcours d'utilisation

Imaginons que votre entreprise soit une agence publicitaire qui propose aux utilisateurs un workflow de création de campagne. Vous souhaitez leur proposer des suggestions pendant ce parcours. Vous pouvez utiliser GenerateRecommendationsRequest pour générer des recommandations à la demande et les intégrer à l'interface utilisateur de la création de 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 flux de création de la campagne. Par exemple, il fournit des informations pour créer un seul SitelinkAsset et sélectionne TARGET_SPEND comme stratégie d'enchères intelligentes.

3. Vous envoyez un 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 de création.

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

   • conversion_tracking_status: défini sur l'ConversionTrackingStatus de ce client. Pour savoir comment récupérer ce champ, consultez le guide de démarrage pour 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 qui crée la campagne.

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