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

Vídeo: análise detalhada

As recomendações melhoram as campanhas de algumas maneiras:

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

Para aumentar as pontuações de otimização, use o RecommendationService para recuperar recomendações e, em seguida, aplique ou dispense-as de acordo com elas. Também é possível se inscrever para aplicar automaticamente as recomendações usando o RecommendationSubscriptionService.

Pontuação de otimização

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

A pontuação de otimização é uma estimativa da performance da sua conta do Google Ads e está disponível nos níveis Customer e Campaign.

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

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

1. O metrics.optimization_score_url fornece um link direto para a conta que permite ver informações sobre as recomendações relacionadas na interface do Google Ads.
2. O metrics.optimization_score_uplift informa o quanto a pontuação de otimização aumentaria se todas as recomendações relacionadas fossem aplicadas. É uma estimativa baseada em todas as recomendações disponíveis como um todo, não apenas na soma das pontuações de aumento de cada recomendação.

Para agrupar e ordenar as recomendações retornadas, segmente essas duas métricas por tipo de recomendação usando segments.recommendation_type na sua consulta.

Tipos de recomendação

Tipos de recomendação totalmente compatíveis

RecommendationType	Descrição
CAMPAIGN_BUDGET	Corrigir campanhas limitadas pelo orçamento
KEYWORD	Adicionar novas palavras-chave
TEXT_AD	Adicionar sugestões de anúncios
TARGET_CPA_OPT_IN	Lance de CPA desejado
MAXIMIZE_CONVERSIONS_OPT_IN	Definir lances com a estratégia "Maximizar conversões"
MAXIMIZE_CONVERSION_VALUE_OPT_IN	Definir lances com a estratégia "Maximizar o valor da conversão"
ENHANCED_CPC_OPT_IN	Definir lances com o CPC otimizado
MAXIMIZE_CLICKS_OPT_IN	Definir lances com a estratégia "Maximizar cliques"
OPTIMIZE_AD_ROTATION	Usar a rotação de anúncios otimizada
MOVE_UNUSED_BUDGET	Transfira os orçamentos não utilizados para os restritos
TARGET_ROAS_OPT_IN	Lances com ROAS desejado
FORECASTING_CAMPAIGN_BUDGET	Corrija as campanhas que, no futuro, devem ser limitadas pelo orçamento
RESPONSIVE_SEARCH_AD	Adicionar novo anúncio responsivo de pesquisa
MARGINAL_ROI_CAMPAIGN_BUDGET	Ajustar o orçamento da campanha para aumentar o ROI
USE_BROAD_MATCH_KEYWORD	Use a correspondência ampla para campanhas baseadas em conversão com lances automáticos.
RESPONSIVE_SEARCH_AD_ASSET	Adicionar recursos de anúncios responsivos de pesquisa a um anúncio
RESPONSIVE_SEARCH_AD_IMPROVE_AD_STRENGTH	Melhorar a qualidade de um anúncio responsivo de pesquisa
DISPLAY_EXPANSION_OPT_IN	Atualizar uma campanha para usar a expansão de display
SEARCH_PARTNERS_OPT_IN	Ampliar o alcance com parceiros de pesquisa do Google
CUSTOM_AUDIENCE_OPT_IN	Criar um público-alvo personalizado
IMPROVE_DISCOVERY_AD_STRENGTH	Melhorar a qualidade dos anúncios nas campanhas Geração de demanda
UPGRADE_SMART_SHOPPING_CAMPAIGN_TO_PERFORMANCE_MAX	Fazer upgrade de uma campanha inteligente do Shopping para uma campanha Performance Max
UPGRADE_LOCAL_CAMPAIGN_TO_PERFORMANCE_MAX	Fazer upgrade de uma campanha local legada para uma campanha Performance Max
SHOPPING_MIGRATE_REGULAR_SHOPPING_CAMPAIGN_OFFERS_TO_PERFORMANCE_MAX	Migrar ofertas segmentadas por campanhas padrão do Shopping para campanhas Performance Max atuais
MIGRATE_DYNAMIC_SEARCH_ADS_CAMPAIGN_TO_PERFORMANCE_MAX	Migrar anúncios dinâmicos de pesquisa para campanhas Performance Max
PERFORMANCE_MAX_OPT_IN	Criar campanhas Performance Max na sua conta
IMPROVE_PERFORMANCE_MAX_AD_STRENGTH	Melhore a qualidade do grupo de recursos de uma campanha Performance Max para uma classificação "Excelente"
PERFORMANCE_MAX_FINAL_URL_OPT_IN	Ative a expansão de URL final nas suas campanhas Performance Max
RAISE_TARGET_CPA_BID_TOO_LOW	Aumentar o CPA desejado quando ele é muito baixo e há poucas conversões ou nenhuma
FORECASTING_SET_TARGET_ROAS	Aumente o orçamento antes de um evento sazonal com previsão de aumento do tráfego e mude a estratégia de lances de "Maximizar o valor da conversão" para ROAS desejado.
LEAD_FORM	Adicionar recursos de formulário de lead a uma campanha
CALLOUT_ASSET	Adicionar recursos de frase de destaque no nível da campanha ou do cliente
SITELINK_ASSET	Adicionar recursos de sitelink no nível da campanha ou do cliente
CALL_ASSET	Adicionar recursos de ligação à campanha ou ao cliente
SHOPPING_ADD_AGE_GROUP	Adicione o atributo de idade às ofertas rebaixadas devido a uma idade ausente
SHOPPING_ADD_COLOR	Adicionar uma cor a ofertas que são rebaixadas devido a uma cor ausente
SHOPPING_ADD_GENDER	Adicionar um gênero a ofertas que são rebaixadas devido à ausência de gênero
SHOPPING_ADD_GTIN	Adicionar um GTIN (Número global do item comercial) a ofertas que foram rebaixadas por falta de um GTIN
SHOPPING_ADD_MORE_IDENTIFIERS	Adicionar mais identificadores às ofertas que são rebaixadas devido à ausência de identificadores
SHOPPING_ADD_SIZE	Adicione o tamanho às ofertas rebaixadas por causa de um tamanho ausente
SHOPPING_ADD_PRODUCTS_TO_CAMPAIGN	Adicionar produtos para uma campanha veicular
SHOPPING_FIX_DISAPPROVED_PRODUCTS	Corrigir produtos reprovados
SHOPPING_TARGET_ALL_OFFERS	Criar uma campanha abrangente que segmente todas as ofertas
SHOPPING_FIX_SUSPENDED_MERCHANT_CENTER_ACCOUNT	Corrigir problemas de suspensão da conta do Merchant Center
SHOPPING_FIX_MERCHANT_CENTER_ACCOUNT_SUSPENSION_WARNING	Corrigir problemas de aviso de suspensão da conta do Merchant Center
DYNAMIC_IMAGE_EXTENSION_OPT_IN	Ativar as extensões de imagem dinâmicas na conta
RAISE_TARGET_CPA	Aumentar o CPA desejado
LOWER_TARGET_ROAS	ROAS desejado mais baixo
FORECASTING_SET_TARGET_CPA	Definir um CPA desejado para campanhas que não têm um especificado antes de um evento sazonal que deve aumentar o tráfego
SET_TARGET_CPA	Definir um CPA desejado para campanhas que não têm um especificado
SET_TARGET_ROAS	Definir um ROAS desejado para campanhas que não têm um ROAS especificado
REFRESH_CUSTOMER_MATCH_LIST	Atualizar uma lista de clientes que não tenha sido atualizada nos últimos 90 dias
IMPROVE_GOOGLE_TAG_COVERAGE	Implantar a tag do Google em mais páginas
CALLOUT_EXTENSION (obsoleto)	Obsoleto. Use CALLOUT_ASSET
SITELINK_EXTENSION (obsoleto)	Descontinuado: use SITELINK_ASSET.
CALL_EXTENSION (obsoleto)	Descontinuado: use CALL_ASSET.
KEYWORD_MATCH_TYPE (obsoleto)	Descontinuado: use USE_BROAD_MATCH_KEYWORD.

Assista a este vídeo para saber mais

Processar tipos sem suporte

Recuperar recomendações

Vídeo: programação em tempo real

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

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

Encontre todos os campos específicos da recomendação no campo de união recommendation.

Impacto da recomendação

Alguns tipos de recomendação preenchem o campo impact da recomendação. RecommendationImpact contém uma estimativa do impacto na performance da conta como resultado da aplicação da recomendação. As métricas de recomendação a seguir estão disponíveis nos campos impact.base_metrics e impact.potential_metrics:

• impressions

• clicks

• cost_micros

• conversions

• all_conversions

• 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 mostra alguns detalhes:

Java

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
      

C#

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

PHP

$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
      

Python

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
      

Ruby

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
      

Perl

# 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, elas podem ser alteradas diariamente ou até várias vezes por dia. Quando isso acontece, o resource_name de um objeto de recomendação pode ficar obsoleto depois que a recomendação é recuperada.

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

Aplicar recomendações

Vídeo: aplicar recomendações

É possível aplicar recomendações ativas ou dispensadas com o método ApplyRecommendation da RecommendationService.

Os tipos de recomendação podem ter parâmetros obrigatórios ou opcionais. A maioria das recomendações vem com valores recomendados que são usados por padrão.

Não é possível definir contas para aplicação automática de recomendações em todos os tipos de recomendação. No entanto, é possível implementar um comportamento semelhante para os tipos de recomendação com suporte total da API Google Ads. Consulte o exemplo de código DetectAndApplyRecommendations para saber mais.

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

Importante: ao aplicar palavras-chave recomendadas da recomendação para adicionar novas palavras-chave, é sua responsabilidade garantir que seus anúncios obedeçam às políticas de publicidade depois que as palavras-chave forem inseridas.

Exemplo de código

O código a seguir demonstra como criar o ApplyRecommendationOperation e como substituir os valores recomendados se você quiser substituí-los pelos seus.

Java

/** 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
      

C#

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
      

PHP

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
      

Python

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
      

Ruby

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
      

Perl

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
      

O próximo exemplo chama ApplyRecommendation, enviando as operações de aplicação de recomendação que foram criadas no código anterior.

Java

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

C#

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
      

PHP

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
      

Python

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
      

Ruby

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
      

Perl

# 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
      

Assista estes vídeos para saber mais

Aplicar parâmetros

Em massa

Erros

Testes

Dispensar recomendações

Vídeo: dispensar recomendações

É possível dispensar recomendações com o RecommendationService. A estrutura do código é semelhante à aplicação de recomendações, mas você usa DismissRecommendationOperation e RecommendationService.DismissRecommendation.

Assista estes vídeos para saber mais

Em massa

Erros

Testes

Aplique recomendações automaticamente

É possível usar o RecommendationSubscriptionService para aplicar automaticamente recomendações de um tipo específico.

Para se inscrever em um tipo de recomendação específico, crie um objeto RecommendationSubscription, defina o campo type como um dos tipos de recomendação aceitos e defina o campo status como ENABLED.

Tipos de recomendações com suporte para assinatura

• 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

Extrair assinaturas

Para saber mais sobre as assinaturas de recomendação de uma conta, consulte o recurso recommendation_subscription.

Para conferir as mudanças aplicadas automaticamente, consulte o recurso change_event, filtrando o change_event.client_type para GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Recomendações ao criar campanhas

É possível usar RecommendationService.GenerateRecommendationsRequest para gerar recomendações durante a criação da campanha para um determinado conjunto de tipos de recomendação.

GenerateRecommendations aceita como entrada um ID do cliente, um tipo de canal de publicidade que precisa ser SEARCH ou PERFORMANCE_MAX, uma lista de tipos de recomendação a serem gerados e vários pontos de dados dependentes dos tipos especificados. Ele gera uma lista de objetos Recommendation com base nos dados fornecidos. Se não houver dados suficientes para gerar uma recomendação para a recommendation_types solicitada ou se a campanha já estiver no estado recomendado, o conjunto de resultados não vai conter uma recomendação para esse tipo. Verifique se o aplicativo lida com o caso em que nenhuma recomendação é retornada para os tipos de recomendação solicitados.

Importante: o RecommendationService não gera erros quando dados insuficientes são fornecidos para um determinado tipo de recomendação. Consulte a documentação para determinar quais dados fornecer.

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

RecommendationType	Campos obrigatórios	Campos opcionais
CAMPAIGN_BUDGET (a partir da v18)	Nas campanhas de pesquisa e Performance Max, os seguintes campos são obrigatórios: final_url bidding_strategy_type Apenas para campanhas de pesquisa, os seguintes campos também são obrigatórios: country_code language_code positive_location_id ou negative_location_id ad_group_info.keywords bidding_info. bidding_strategy_target_info. target_impression_share_info se a estratégia de lances estiver definida como TARGET_IMPRESSION_SHARE	asset_group_info budget_info
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 Observação: o objeto SitelinkAssetRecommendation retornado terá listas vazias. Se a resposta GenerateRecommendations contiver um SitelinkAssetRecommendation, ela poderá ser tratada como um indicador para adicionar pelo menos um recurso de sitelink à campanha.	campaign_sitelink_count
TARGET_CPA_OPT_IN	conversion_tracking_status bidding_info
TARGET_ROAS_OPT_IN	conversion_tracking_status bidding_info

Exemplo de fluxo de uso

Suponha que sua empresa seja uma agência de publicidade que oferece um fluxo de trabalho de construção de campanhas aos usuários, e você quer oferecer sugestões a eles durante esse fluxo. Use GenerateRecommendationsRequest para gerar recomendações sob demanda e incorporá-las à interface do usuário da criação de campanhas.

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 do fluxo de construção da campanha. Por exemplo, ela fornece detalhes para criar uma única SitelinkAsset e seleciona TARGET_SPEND como a estratégia de Lances inteligentes.

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

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

   • bidding_info: define o campo bidding_strategy_type aninhado como TARGET_SPEND.

   • conversion_tracking_status: definido como ConversionTrackingStatus do cliente. Para orientações sobre como recuperar esse campo, acesse o guia Primeiros passos 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 usar as recomendações no GenerateRecommendationsResponse (nesse caso, um SitelinkAssetRecommendation e um MaximizeClicksOptInRecommendation) e sugeri-las ao usuário exibindo-as na interface de criação da campanha. Se o usuário aceitar uma sugestão, você poderá incorporá-la à solicitação de criação de campanha assim que o usuário concluir o fluxo de construção da campanha.