Recomendações

Vídeo: análise detalhada

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

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

Para aumentar as pontuações de otimização, use RecommendationService para recuperar recomendações e, em seguida, aplique ou dispense-as conforme necessário.

Pontuação de otimização

Vídeo: análise detalhada

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

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

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

  1. O metrics.optimization_score_url oferece um link direto para a conta para visualizar 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.

O valor de optimization_score_uplift é apenas uma aproximação. Isso ocorre porque o aumento de otimização é calculado individualmente para cada recomendação, e o efeito combinado da implementação de várias recomendações pode não ser uma soma precisa de cada uma isoladamente.

Tipos de recomendação

Vídeo: lidar com tipos não compatíveis

A API Google Ads é totalmente compatível com os seguintes tipos de recomendação:

RecommendationType (link em inglês) 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 com CPA desejado
MAXIMIZE_CONVERSIONS_OPT_IN Lance com a estratégia "Maximizar conversões"
ENHANCED_CPC_OPT_IN Lance com CPC otimizado
SEARCH_PARTNERS_OPT_IN Expandir o alcance com parceiros de pesquisa do Google
MAXIMIZE_CLICKS_OPT_IN Lance com estratégia "Maximizar cliques"
OPTIMIZE_AD_ROTATION Use rotações de anúncios otimizadas
CALLOUT_EXTENSION Adicionar extensões de frase de destaque à campanha
SITELINK_EXTENSION Adicionar extensões de sitelink à campanha
CALL_EXTENSION Adicionar extensões de chamada à campanha
KEYWORD_MATCH_TYPE (deprecated) Alterar os tipos de correspondência de palavra-chave
MOVE_UNUSED_BUDGET Mover os itens não utilizados para os orçamentos restritos
TARGET_ROAS_OPT_IN Lance com ROAS desejado
FORECASTING_CAMPAIGN_BUDGET Corrija campanhas que provavelmente serão 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úncio responsivo de pesquisa a um anúncio
UPGRADE_SMART_SHOPPING_CAMPAIGN_TO_PERFORMANCE_MAX Fazer upgrade de uma campanha inteligente do Shopping para uma campanha de maior desempenho
RESPONSIVE_SEARCH_AD_IMPROVE_AD_STRENGTH Melhorar a qualidade do anúncio responsivo de pesquisa

Recuperar recomendações

Vídeo: programação ao vivo

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

Para cada tipo de recomendação, os detalhes da recomendação são fornecidos em um campo específico recommendation com um tipo específico:

RecommendationType (link em inglês) recommendation Tipo
CAMPAIGN_BUDGET campaign_budget_recommendation CampaignBudgetRecommendation
KEYWORD keyword_recommendation KeywordRecommendation
TEXT_AD text_ad_recommendation TextAdRecommendation
TARGET_CPA_OPT_IN target_cpa_opt_in_recommendation TargetCpaOptInRecommendation
MAXIMIZE_CONVERSIONS_OPT_IN maximize_conversions_opt_in_recommendation MaximizeConversionsOptInRecommendation
ENHANCED_CPC_OPT_IN enhanced_cpc_opt_in_recommendation EnhancedCpcOptInRecommendation
SEARCH_PARTNERS_OPT_IN search_partners_opt_in_recommendation SearchPartnersOptInRecommendation
MAXIMIZE_CLICKS_OPT_IN maximize_clicks_opt_in_recommendation MaximizeClicksOptInRecommendation
OPTIMIZE_AD_ROTATION optimize_ad_rotation_recommendation OptimizeAdRotationRecommendation
CALLOUT_EXTENSION callout_extension_recommendation CalloutExtensionRecommendation
SITELINK_EXTENSION sitelink_extension_recommendation SitelinkExtensionRecommendation
CALL_EXTENSION call_extension_recommendation CallExtensionRecommendation
KEYWORD_MATCH_TYPE (obsoleto) keyword_match_type_recommendation KeywordMatchTypeRecommendation
MOVE_UNUSED_BUDGET move_unused_budget_recommendation MoveUnusedBudgetRecommendation
TARGET_ROAS_OPT_IN target_roas_opt_in_recommendation TargetRoasOptInRecommendation
FORECASTING_CAMPAIGN_BUDGET forecasting_campaign_budget_recommendation CampaignBudgetRecommendation
RESPONSIVE_SEARCH_AD responsive_search_ad_recommendation ResponsiveSearchAdRecommendation
MARGINAL_ROI_CAMPAIGN_BUDGET marginal_roi_campaign_budget_recommendation CampaignBudgetRecommendation
USE_BROAD_MATCH_KEYWORD use_broad_match_keyword_recommendation UseBroadMatchKeywordRecommendation
RESPONSIVE_SEARCH_AD_ASSET responsive_search_ad_asset_recommendation ResponsiveSearchAdAssetRecommendation

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

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.V11.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($customerId, $query, ['pageSize' => 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::V11::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, as recomendações podem mudar diariamente ou até várias vezes ao dia. Quando isso acontece, um objeto de recomendação resource_name pode se tornar obsoleto após a recomendação ser recuperada.

É uma boa prática tomar medidas quanto às recomendações logo após a recuperação.

Aplicar recomendações

Vídeo: análise detalhada

A configuração de contas para aplicação automática de recomendações não é compatível com a API Google Ads, mas é possível implementar um comportamento semelhante para os tipos de recomendações totalmente compatíveis com a API Google Ads. Consulte o exemplo de código DetectAndApplyRecommendations para saber mais.

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

Os tipos de recomendação podem ter parâmetros obrigatórios ou opcionais. A maioria das recomendações é fornecida com os valores recomendados usados por padrão. Veja detalhes de recomendação.

Use o campo apply_parameters de ApplyRecommendationOperation para aplicar recomendações com valores de parâmetro específicos. Cada tipo de recomendação adequado tem o próprio campo:

RecommendationType (link em inglês) apply_parameter Tipo
CAMPAIGN_BUDGET campaign_budget CampaignBudgetParameters
KEYWORD keyword KeywordParameters
TEXT_AD text_ad TextAdParameters
TARGET_CPA_OPT_IN target_cpa_opt_in TargetCpaOptInParameters
MAXIMIZE_CONVERSIONS_OPT_IN - -
ENHANCED_CPC_OPT_IN - -
SEARCH_PARTNERS_OPT_IN - -
MAXIMIZE_CLICKS_OPT_IN - -
OPTIMIZE_AD_ROTATION - -
CALLOUT_EXTENSION callout_extension CalloutExtensionParameters
SITELINK_EXTENSION sitelink_extension SitelinkExtensionParameters
CALL_EXTENSION call_extension CallExtensionParameters
KEYWORD_MATCH_TYPE (obsoleto) - -
MOVE_UNUSED_BUDGET move_unused_budget MoveUnusedBudgetParameters
TARGET_ROAS_OPT_IN target_roas_opt_in TargetRoasOptInParameters
FORECASTING_CAMPAIGN_BUDGET campaign_budget CampaignBudgetParameters
RESPONSIVE_SEARCH_AD responsive_search_ad ResponsiveSearchAdParameters
MARGINAL_ROI_CAMPAIGN_BUDGET campaign_budget CampaignBudgetParameters
USE_BROAD_MATCH_KEYWORD use_broad_match_keyword UseBroadMatchKeywordRecommendation
RESPONSIVE_SEARCH_AD_ASSET responsive_search_ad_asset ResponsiveSearchAdAssetParameters

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.V11.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(
        $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::V11::Utils::ResourceNames::recommendation(
    $customer_id, $recommendation_id);

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

Você pode 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 a estes vídeos para saber mais

Em massa

Erros

Testes