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

Vídeo: análise detalhada

As recomendações podem melhorar as campanhas das seguintes maneiras:

  • Apresentar 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, use o RecommendationService para extrair recomendações e aplique ou dispense-as conforme necessário. A partir da v15 da API Google Ads, também é possível se inscrever para receber recomendações aplicadas automaticamente 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 que 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. Recupere a pontuação de otimização e a ponderação das contas e multiplique-as (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, com informações sobre as recomendações relacionadas na IU do Google Ads.
  2. O metrics.optimization_score_uplift informa quanto a pontuação de otimização aumentaria se todas as recomendações relacionadas fossem aplicadas. Ela é 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 as duas métricas por tipo de recomendação usando segments.recommendation_type na consulta.

Tipos de recomendação

Tipos de recomendação com suporte total

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 Definir lances com CPA desejado
MAXIMIZE_CONVERSIONS_OPT_IN Dar 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 Dê lances com a estratégia "Maximizar cliques"
OPTIMIZE_AD_ROTATION Usar rotações de anúncios otimizadas
MOVE_UNUSED_BUDGET Mover o caso não usado para orçamentos restritos
TARGET_ROAS_OPT_IN Definir lances com o ROAS desejado
FORECASTING_CAMPAIGN_BUDGET Corrija as campanhas que poderão ser limitadas pelo orçamento no futuro
RESPONSIVE_SEARCH_AD Adicionar novo anúncio responsivo de pesquisa
MARGINAL_ROI_CAMPAIGN_BUDGET Ajuste o orçamento da campanha para aumentar o ROI
USE_BROAD_MATCH_KEYWORD Use a correspondência ampla para campanhas com base em conversões que usam 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 Inclusão da Rede 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 em 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 Migre ofertas segmentadas pelas campanhas padrão do Shopping para campanhas Performance Max
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 Melhorar 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 Aumente o CPA desejado quando ele estiver muito baixo e houver poucas ou nenhuma conversão
FORECASTING_SET_TARGET_ROAS Aumentar o orçamento antes de um evento sazonal com previsão de aumento do tráfego e mudar a estratégia de lances de "Maximizar o valor da conversão" para o 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 ao 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 que são rebaixadas devido à ausência de uma idade
SHOPPING_ADD_COLOR Adicione uma cor às ofertas que são rebaixadas devido à ausência de uma cor
SHOPPING_ADD_GENDER Adicione um gênero às ofertas que são rebaixadas devido à ausência do gênero
SHOPPING_ADD_GTIN Adicione um Número global do item comercial (GTIN) às ofertas rebaixadas devido à ausência de um GTIN
SHOPPING_ADD_MORE_IDENTIFIERS Adicione mais identificadores às ofertas que são rebaixadas devido à ausência de identificadores
SHOPPING_ADD_SIZE Adicione o tamanho às ofertas que são rebaixadas devido à ausência de um tamanho
SHOPPING_ADD_PRODUCTS_TO_CAMPAIGN Adicione produtos para que uma campanha seja veiculada
SHOPPING_FIX_DISAPPROVED_PRODUCTS Corrigir produtos reprovados
SHOPPING_TARGET_ALL_OFFERS Crie uma campanha abrangente que segmente todas as ofertas
SHOPPING_FIX_SUSPENDED_MERCHANT_CENTER_ACCOUNT Corrigir problemas de suspensão de 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 menor
FORECASTING_SET_TARGET_CPA Definir um CPA desejado para campanhas que não têm um valor especificado antes de um evento sazonal com previsão de aumento do tráfego
SET_TARGET_CPA Definir um CPA desejado para campanhas que não têm um CPA especificado
SET_TARGET_ROAS Definir um ROAS desejado para campanhas que não têm um especificado
REFRESH_CUSTOMER_MATCH_LIST Atualizar uma lista de clientes que não foi 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) Obsoleto. Use SITELINK_ASSET.
CALL_EXTENSION (obsoleto) Obsoleto. Use CALL_ASSET.
KEYWORD_MATCH_TYPE (obsoleto) Obsoleto. Use USE_BROAD_MATCH_KEYWORD.

Para saber mais, assista ao vídeo

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 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 de 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 seguintes métricas de recomendação estão disponíveis 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 TEXT_AD de uma conta e mostra alguns dos detalhes:

Java

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

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

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

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

C#

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

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

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

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

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

PHP

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

    // Issues a search request by specifying page size.
    $response = $googleAdsServiceClient->search(
        SearchGoogleAdsRequest::build($customerId, $query)->setPageSize(self::PAGE_SIZE)
    );

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

Python

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

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

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

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

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

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

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

Ruby

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

  ga_service = client.service.google_ads

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

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

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

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

Perl

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

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

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

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

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

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

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

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

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

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

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

  return 1;
}
      

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

É uma boa prática tomar medidas em relação à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 recomendações com aplicação automática em alguns tipos de recomendações. No entanto, você pode implementar um comportamento semelhante para os tipos de recomendação que são totalmente compatíveis com a API Google Ads. Consulte o exemplo de código DetectAndApplyRecommendations para saber mais.

Use o campo de união apply_parameters 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 esses valores de parâmetro.

Exemplo de código

O exemplo de código a seguir ilustra como aplicar uma recomendação com os parâmetros de aplicação recomendados:

Java

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

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

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

C#

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

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

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

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

PHP

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

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

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

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

Python

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

    apply_recommendation_operation = client.get_type(
        "ApplyRecommendationOperation"
    )

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

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

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

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

Ruby

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

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

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

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

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

Perl

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

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

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

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

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

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

  return 1;
}
      

Assista a estes vídeos para saber mais

Aplicar parâmetros

Em massa

Erros

Testes

Dispensar recomendações

Vídeo: dispensar recomendações

É possível dispensar as recomendações com RecommendationService. A estrutura do código é semelhante à aplicação de recomendações, mas, em vez disso, DismissRecommendationOperation e RecommendationService.DismissRecommendation são usados.

Assista a estes vídeos para saber mais

Em massa

Erros

Testes

Aplique recomendações automaticamente

A partir da v15 da API 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 um objeto RecommendationSubscription, defina o campo type como um dos tipos de recomendação com suporte e defina o campo status como ENABLED.

Tipos de recomendações com suporte a assinaturas

  • 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

Recuperar assinaturas

Para ver informações 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 change_client_type por GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Recomendações ao criar campanhas

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

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

A tabela a seguir descreve os tipos de recomendação compatíveis com GenerateRecommendations e os campos que você precisa fornecer para receber recomendações para esse tipo. A prática recomendada é enviar a solicitação GenerateRecommendations depois que todas as informações forem coletadas relacionadas aos tipos de recomendação solicitados. 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
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 conterá listas vazias. Se a resposta GenerateRecommendations contiver um SitelinkAssetRecommendation, 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 fornece um fluxo de trabalho de construção de campanha para os usuários e você queira oferecer sugestões aos usuários durante esse fluxo. Use GenerateRecommendationsRequest para gerar recomendações sob demanda e incorporá-las à interface do usuário para construção da campanha.

O fluxo de uso pode ser semelhante ao seguinte:

  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 criação da campanha. Por exemplo, ele fornece detalhes para criar um único 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: defina como 1, que é o número de recursos de sitelink na campanha em andamento.

    • bidding_info: defina o campo aninhado bidding_strategy_type como TARGET_SPEND.

    • conversion_tracking_status: definido como o ConversionTrackingStatus do cliente. Para orientações sobre como recuperar esse campo, consulte o guia Primeiros passos para 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 no GenerateRecommendationsResponse (nesse caso, um SitelinkAssetRecommendation e 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 da campanha assim que o usuário concluir o fluxo de criação da campanha.