Pontuação de otimização e recomendações

ondemand_video Vídeo: análise detalhada

As recomendações podem melhorar. suas campanhas de algumas maneiras:

• Introduzir recursos novos e relevantes
• Aproveite melhor seu orçamento com lances, palavras-chave e anúncios aprimorados
• Aumente a performance geral e a eficiência das suas campanhas

Para aumentar as pontuações de otimização, você pode usar o RecommendationService para recuperar recomendações e, em seguida, aplique ou dispense-as de acordo com elas. A partir da v15 da API Google Ads, você também pode se inscrever para aplicar automaticamente usando RecommendationSubscriptionService.

Pontuação de otimização

ondemand_video Vídeo: pontuação de otimização

A pontuação de otimização é uma estimativa do desempenho e da disponibilidade da sua conta do Google Ads em Customer e Níveis de Campaign.

A Customer.optimization_score_weight só está disponível para contas que não são de administrador e é usado para calcular o valor pontuação de otimização de várias contas. Recuperar a pontuação de otimização peso da pontuação de otimização das contas e multiplicá-las (Customer.optimization_score * Customer.optimization_score_weight) a calcular a pontuação de otimização geral.

Há métricas relacionadas à otimização disponíveis para customer e campaign relatórios:

1. A metrics.optimization_score_url fornece um link direto para a conta para visualizar informações sobre o recomendações na interface do Google Ads.
2. A metrics.optimization_score_uplift informa quanto a pontuação de otimização aumentaria se todos os as recomendações sejam aplicadas. A estimativa é baseada em todos os recomendações como um todo, não apenas a soma das pontuações de aumento para cada recomendação.

Para agrupar e ordenar as recomendações retornadas, você pode segmentar ambos métricas por tipo de recomendação usando segments.recommendation_type na sua consulta.

Tipos de recomendação

Recuperar recomendações

ondemand_video Vídeo: programação em tempo real

Como a maioria das outras entidades na API Google Ads, Recommendation objetos são buscados usando o GoogleAdsService.SearchStream com uma consulta na linguagem de consulta do Google Ads.

Para cada tipo de recomendação, os detalhes são fornecidos em um no campo específico de recomendação. Por exemplo, CAMPAIGN_BUDGET recomendação detalhes estão na campaign_budget_recommendation e estão em um formato CampaignBudgetRecommendation objeto.

Encontre todos os campos específicos das recomendações na Campo de união recommendation.

Impacto da recomendação

Alguns tipos de recomendação preenchem impact da recomendação. RecommendationImpact contém uma estimativa do impacto no desempenho da conta como resultado de para aplicar a recomendação. O seguinte métricas de recomendação são disponível nos campos impact.base_metrics e impact.potential_metrics:

• impressions

• clicks

• cost_micros

• conversions

• all_conversions (disponível a partir da v16 da API Google Ads)

• video_views

Exemplo de código

O exemplo de código a seguir recupera todas as recomendações disponíveis e dispensadas do tipo KEYWORD de uma conta e imprime alguns detalhes:

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.V17.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
      

Entre em ação

Qualquer recomendação recuperada pode ser aplicada ou dispensada.

Dependendo do tipo de recomendação, as recomendações podem mudar diariamente várias vezes por dia. Quando isso acontece, uma recomendação resource_name do objeto pode se tornam obsoletas depois que a recomendação é recuperada.

É recomendável agir quanto às recomendações logo após a recuperação.

Aplicar recomendações

ondemand_video Vídeo: aplicar recomendações

É possível aplicar recomendações ativas ou dispensadas com o ApplyRecommendation da classe RecommendationService

Os tipos de recomendação podem ter parâmetros obrigatórios ou opcionais. Mais frequentes as recomendações vêm com valores recomendados, que são usados por padrão.

Não é possível definir contas para recomendações autoaplicadas. com suporte para todos os tipos de recomendação. No entanto, é possível implementar comportamento para os tipos de recomendação totalmente compatíveis com a API Google Ads. Consulte o código DetectAndApplyRecommendations exemplo para saber mais.

Use o apply_parameters campo de união de ApplyRecommendationOperation para aplicar recomendações com valores de parâmetros específicos. Cada tipo de recomendação adequado tem seu próprio campo. Qualquer tipo de recomendação não listado no campo apply_parameters não usa desses valores de parâmetro.

Exemplo de código

O código a seguir demonstra como criar a ApplyRecommendationOperation e como substituir os valores recomendados se quiser substituí-los pelo seu por conta própria.

/** 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::V17::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::V17::Resources::Ad->new({
  #   id => "INSERT_AD_ID_AS_INTEGER_HERE"
  # });
  # my $text_ad_parameters =
  #   Google::Ads::GoogleAds::V17::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::V17::Services::RecommendationService::ApplyRecommendationOperation
    ->new({
      resourceName => $recommendation->{resourceName}});

  return $apply_recommendation_operation;
}
detect_and_apply_recommendations.pl
      

O próximo exemplo chama ApplyRecommendation, enviar as operações de aplicação de recomendação que foram criadas na o código-fonte.

// 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.V17.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
      

Dispensar recomendações

ondemand_video Vídeo: dispensar recomendações

Você pode dispensar recomendações com o RecommendationService O código é semelhante à aplicação de recomendações, mas você usa DismissRecommendationOperation e RecommendationService.DismissRecommendation.

Aplique recomendações automaticamente

A partir da v15 da API do Google Ads, você pode usar o RecommendationSubscriptionService para aplicar automaticamente recomendações de um tipo específico.

Para se inscrever em um tipo específico de recomendação, crie uma objeto RecommendationSubscription, defina o campo type como um dos a recomendação com suporte types e defina os status para ENABLED.

Recuperar assinaturas

Para mais informações sobre as recomendações de assinaturas de uma conta, consulte o recommendation_subscription.

Para visualizar as alterações que foram aplicadas automaticamente, consulte o change_event, filtrando os change_client_type para GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Recomendações na criação da campanha

A partir da v16 da API Google Ads, você pode usar RecommendationService.GenerateRecommendationsRequest para gerar recomendações durante a criação da campanha para um determinado conjunto de tipos de recomendações.

GenerateRecommendations aceita como entrada um ID de cliente, um canal de publicidade que deve ser SEARCH ou PERFORMANCE_MAX, uma lista de tipos de recomendação a serem gerados e vários pontos de dados que dependem os tipos especificados. Ele gera uma lista de objetos Recommendation com base na dados fornecidos por você. Se não houver dados suficientes para gerar uma recomendação para o(s) solicitado(s) recommendation_types, ou, se a campanha já estiver no estado recomendado, o conjunto de resultados não contêm uma recomendação para esse tipo. Certifique-se de que seu aplicativo lide com o caso em que nenhuma recomendação é retornada para a recomendação solicitada tipos

A tabela a seguir descreve os tipos de recomendações que GenerateRecommendations oferece suporte e os campos que você precisa fornecer para receber recomendações para esse tipo. Como prática recomendada, envie o Solicitação GenerateRecommendations depois que todas as informações forem coletadas relacionadas aos tipos de recomendações solicitados. Para mais detalhes sobre campos obrigatórios e opcionais, incluindo campos aninhados, documentação de referência.

Exemplo de fluxo de uso

Suponha que sua empresa seja uma agência de publicidade que oferece uma campanha fluxo de trabalho de construção e quer oferecer sugestões a eles durante esse fluxo. Você pode usar GenerateRecommendationsRequest gerar recomendações sob demanda e incorporá-las na interface do usuário de criação da campanha.

O fluxo de uso pode ser semelhante a este:

1. Um usuário acessa seu aplicativo para criar uma campanha Performance Max.

2. O usuário fornece algumas informações iniciais como parte da campanha fluxo de construção. Por exemplo, eles dão detalhes para criar um único SitelinkAsset e selecionam TARGET_SPEND como os Lances inteligentes estratégia.

3. Você envia um GenerateRecommendationsRequest que define os seguintes campos:

   • campaign_sitelink_count: definido como 1, que é o número de recursos de sitelink no trabalho em andamento campanha.

   • bidding_info: Defina o campo aninhado bidding_strategy_type como TARGET_SPEND.

   • conversion_tracking_status: defina como ConversionTrackingStatus deste cliente. Para orientações sobre como recuperar este campo, visite a Como começar para o gerenciamento de conversões.

   • Defina recommendation_types como [SITELINK_ASSET, MAXIMIZE_CLICKS_OPT_IN].

   • Defina advertising_channel_type como PERFORMANCE_MAX.

   • customer_id: defina como o ID do cliente que está criando a campanha.

4. Você pode seguir as recomendações GenerateRecommendationsResponse - nesse caso, um SitelinkAssetRecommendation e um MaximizeClicksOptInRecommendation — e sugira-os para o usuário exibindo-os na sua campanha. interface de criação do Cloud. Se o usuário aceitar uma sugestão, você poderá incorporá-lo à solicitação de criação da campanha quando o usuário concluir do fluxo de criação da campanha.