Nivel de optimización y recomendaciones

Video: Análisis detallado

Las recomendaciones pueden mejorar tus campañas de varias maneras:

  • Presenta funciones nuevas y relevantes
  • Aproveche al máximo su presupuesto con ofertas, palabras clave y anuncios mejorados
  • Aumenta el rendimiento y la eficiencia generales de tus campañas

Si quieres aumentar los niveles de optimización, puedes usar RecommendationService para recuperar recomendaciones y, luego, aplicarlas o descartarlas según corresponda. A partir de la versión 15 de la API de Google Ads, también puedes suscribirte a las recomendaciones aplicadas automáticamente mediante el RecommendationSubscriptionService.

Nivel de optimización

Video: Nivel de optimización

El nivel de optimización es una estimación de qué tan bien está configurada tu cuenta de Google Ads para lograr el rendimiento esperado y está disponible en los niveles Customer y Campaign.

Customer.optimization_score_weight solo está disponible para cuentas que no son de administrador y se usa para calcular el nivel de optimización general de varias cuentas. Recupera el nivel de optimización y el peso del nivel de optimización de las cuentas y multiplícalos (Customer.optimization_score * Customer.optimization_score_weight) para calcular el nivel de optimización general.

Hay métricas relacionadas con la optimización disponibles para los informes de customer y campaign:

  1. El objeto metrics.optimization_score_url proporciona un vínculo directo a la cuenta para ver información sobre las recomendaciones relacionadas en la IU de Google Ads.
  2. El objeto metrics.optimization_score_uplift indica cuánto aumentaría el nivel de optimización si se aplican todas las recomendaciones relacionadas. Es una estimación basada en todas las recomendaciones disponibles, no solo en la suma de las puntuaciones de aumento de cada recomendación.

Para agrupar y ordenar las recomendaciones que se muestran, puedes segmentar ambas métricas por tipo de recomendación mediante segments.recommendation_type en tu consulta.

Tipos de recomendación

Tipos de recomendaciones totalmente compatibles

RecommendationType Descripción
CAMPAIGN_BUDGET Cómo corregir las campañas limitadas por el presupuesto
KEYWORD Agrega palabras clave nuevas
TEXT_AD Agregue sugerencias de anuncios
TARGET_CPA_OPT_IN Realizar ofertas con CPA objetivo
MAXIMIZE_CONVERSIONS_OPT_IN Oferta con Maximizar conversiones
MAXIMIZE_CONVERSION_VALUE_OPT_IN Oferta con Maximizar valor de conversión
ENHANCED_CPC_OPT_IN Ofertar con CPC avanzado
MAXIMIZE_CLICKS_OPT_IN Ofertar con Maximizar clics
OPTIMIZE_AD_ROTATION Utiliza las rotaciones de anuncios optimizadas
MOVE_UNUSED_BUDGET Transfiera los presupuestos sin utilizar a presupuestos limitados
TARGET_ROAS_OPT_IN Establece ofertas con ROAS objetivo
FORECASTING_CAMPAIGN_BUDGET Corrige las campañas que se prevé que estarán limitadas por el presupuesto en el futuro
RESPONSIVE_SEARCH_AD Agregar nuevo anuncio de búsqueda responsivo
MARGINAL_ROI_CAMPAIGN_BUDGET Ajusta el presupuesto de la campaña para aumentar el ROI
USE_BROAD_MATCH_KEYWORD Usa la concordancia amplia para las campañas basadas en conversiones con ofertas automáticas
RESPONSIVE_SEARCH_AD_ASSET Agrega recursos de anuncio de búsqueda responsivo a un anuncio
RESPONSIVE_SEARCH_AD_IMPROVE_AD_STRENGTH Mejore la calidad de los anuncios de búsqueda responsivos
DISPLAY_EXPANSION_OPT_IN Actualice una campaña para utilizar la expansión en Display
SEARCH_PARTNERS_OPT_IN Expanda el alcance con los socios de búsqueda de Google
CUSTOM_AUDIENCE_OPT_IN Cree un público personalizado
IMPROVE_DISCOVERY_AD_STRENGTH Mejora la calidad de los anuncios en las campañas de generación de demanda
UPGRADE_SMART_SHOPPING_CAMPAIGN_TO_PERFORMANCE_MAX Cómo actualizar una campaña de Shopping inteligente a una campaña de máximo rendimiento
UPGRADE_LOCAL_CAMPAIGN_TO_PERFORMANCE_MAX Cómo actualizar una campaña local heredada a una campaña de máximo rendimiento
SHOPPING_MIGRATE_REGULAR_SHOPPING_CAMPAIGN_OFFERS_TO_PERFORMANCE_MAX Migre las ofertas segmentadas de las campañas de Shopping normales a las campañas de máximo rendimiento existentes
MIGRATE_DYNAMIC_SEARCH_ADS_CAMPAIGN_TO_PERFORMANCE_MAX Migra los anuncios dinámicos de búsqueda a las campañas de máximo rendimiento
PERFORMANCE_MAX_OPT_IN Crea campañas de máximo rendimiento en tu cuenta
IMPROVE_PERFORMANCE_MAX_AD_STRENGTH Mejora la calidad del grupo de recursos de una campaña de máximo rendimiento para que obtenga una calificación "Excelente".
PERFORMANCE_MAX_FINAL_URL_OPT_IN Activa la Expansión de la URL final en tus campañas de máximo rendimiento
RAISE_TARGET_CPA_BID_TOO_LOW Aumenta el CPA objetivo cuando sea demasiado bajo y haya muy pocas conversiones o ninguna.
FORECASTING_SET_TARGET_ROAS Aumentar el presupuesto antes de un evento de temporada que se prevea que aumentará el tráfico y cambiar la estrategia de ofertas de Maximizar valor de conversión al ROAS objetivo
LEAD_FORM Cómo agregar recursos de formulario de clientes potenciales a una campaña
CALLOUT_ASSET Cómo agregar recursos de texto destacado a nivel de la campaña o del cliente
SITELINK_ASSET Cómo agregar recursos de vínculos a sitios a nivel de la campaña o del cliente
CALL_ASSET Cómo agregar recursos de llamada a nivel de la campaña o del cliente
SHOPPING_ADD_AGE_GROUP Agregar el atributo edad a las ofertas que descenderon de nivel debido a que falta la edad
SHOPPING_ADD_COLOR Agrega un color a las ofertas que descienden de nivel debido a que falta un color.
SHOPPING_ADD_GENDER Agregar un género a las ofertas que descienden de nivel debido a que falta un género
SHOPPING_ADD_GTIN Agregar un GTIN (código comercial global de artículo) a las ofertas que desciendan de nivel porque falta el GTIN
SHOPPING_ADD_MORE_IDENTIFIERS Agrega más identificadores a las ofertas que descienden de nivel debido a que faltan identificadores
SHOPPING_ADD_SIZE Agrega el tamaño a las ofertas que descienden de nivel debido a que falta el tamaño.
SHOPPING_ADD_PRODUCTS_TO_CAMPAIGN Agrega productos para que se publique una campaña
SHOPPING_FIX_DISAPPROVED_PRODUCTS Corrija los productos rechazados
SHOPPING_TARGET_ALL_OFFERS Cree una campaña genérica que se oriente a todas las ofertas.
SHOPPING_FIX_SUSPENDED_MERCHANT_CENTER_ACCOUNT Corrija los problemas de suspensión de cuentas de Merchant Center
SHOPPING_FIX_MERCHANT_CENTER_ACCOUNT_SUSPENSION_WARNING Corrija los problemas relacionados con las advertencias de suspensión de cuentas de Merchant Center
DYNAMIC_IMAGE_EXTENSION_OPT_IN Habilitar las extensiones de imagen dinámicas en la cuenta
RAISE_TARGET_CPA Aumentar el CPA objetivo
LOWER_TARGET_ROAS de reducción del ROAS objetivo
FORECASTING_SET_TARGET_CPA Establecer un CPA objetivo para las campañas que no tienen uno especificado antes de un evento de temporada que esté previsto que aumente el tráfico
SET_TARGET_CPA Establezca un CPA objetivo para las campañas que no tienen uno especificado
SET_TARGET_ROAS Establezca un ROAS objetivo para las campañas que no tienen uno especificado
REFRESH_CUSTOMER_MATCH_LIST Actualizar una lista de clientes que no se actualizó en los últimos 90 días
IMPROVE_GOOGLE_TAG_COVERAGE Implementa la etiqueta de Google en más páginas
CALLOUT_EXTENSION (obsoleta) Obsoleto; usa CALLOUT_ASSET en su lugar
SITELINK_EXTENSION (obsoleta) Obsoleto; usa SITELINK_ASSET en su lugar
CALL_EXTENSION (obsoleta) Obsoleto; usa CALL_ASSET en su lugar
KEYWORD_MATCH_TYPE (obsoleta) Obsoleto; usa USE_BROAD_MATCH_KEYWORD en su lugar

Mira este video para obtener más información

Cómo controlar tipos no compatibles

Recupera recomendaciones

Video: Programación en vivo

Al igual que la mayoría de las otras entidades de la API de Google Ads, los objetos Recommendation se recuperan mediante GoogleAdsService.SearchStream con una consulta del lenguaje de consulta de Google Ads.

Para cada tipo de recomendación, los detalles se proporcionan en un campo específico de la recomendación. Por ejemplo, los detalles de la recomendación CAMPAIGN_BUDGET están en el campo campaign_budget_recommendation y se unen en un objeto CampaignBudgetRecommendation.

Busca todos los campos específicos de recomendación en el campo de unión recommendation.

Impacto en las recomendaciones

Algunos tipos de recomendación propagan el campo impact de la recomendación. RecommendationImpact contiene una estimación del impacto en el rendimiento de la cuenta como resultado de la aplicación de la recomendación. Las siguientes métricas de recomendación están disponibles en los campos impact.base_metrics y impact.potential_metrics:

  • impressions

  • clicks

  • cost_micros

  • conversions

  • all_conversions (disponible a partir de la versión 16 de la API de Google Ads)

  • video_views

Ejemplo de código

El siguiente código de muestra recupera todas las recomendaciones disponibles y descartadas de tipo TEXT_AD de una cuenta y, luego, imprime algunos de sus detalles:

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}"')
      

Rita

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;
}
      

Toma medidas

Se puede aplicar o descartar cualquier recomendación recuperada.

Según el tipo de recomendación, las recomendaciones pueden cambiar todos los días o incluso varias veces al día. Cuando eso sucede, el resource_name de un objeto de recomendación puede quedar obsoleto después de que se recupera la recomendación.

Es una buena práctica tomar medidas en función de las recomendaciones poco después de su recuperación.

Aplica recomendaciones

Video: Cómo aplicar recomendaciones

Puedes aplicar recomendaciones activas o descartadas con el método ApplyRecommendation de RecommendationService.

Los tipos de recomendaciones pueden tener parámetros opcionales o obligatorios. La mayoría de las recomendaciones incluyen valores recomendados que se usan de forma predeterminada.

La configuración de cuentas para las recomendaciones aplicadas automáticamente no es compatible con todos los tipos de recomendaciones. Sin embargo, puedes implementar un comportamiento similar para los tipos de recomendaciones que son totalmente compatibles con la API de Google Ads. Consulta el ejemplo de código DetectAndApplyRecommendations para obtener más información.

Usa el campo de unión apply_parameters de ApplyRecommendationOperation para aplicar recomendaciones con valores de parámetros específicos. Cada tipo de recomendación adecuado tiene su propio campo. Cualquier tipo de recomendación que no aparezca en el campo apply_parameters no usa estos valores de parámetros.

Ejemplo de código

En el siguiente ejemplo de código, se muestra cómo aplicar una recomendación con los parámetros de aplicación 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}'"
    )
      

Rita

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;
}
      

Mira estos videos para obtener más información

Aplicar parámetros

Subida masiva

Errores

Pruebas

Cómo descartar recomendaciones

Video: Cómo descartar recomendaciones

Puedes descartar recomendaciones con la RecommendationService. La estructura de código es similar a la aplicación de recomendaciones, pero, en su lugar, puedes usar DismissRecommendationOperation y RecommendationService.DismissRecommendation.

Mira estos videos para obtener más información

Subida masiva

Errores

Pruebas

Aplique automáticamente las recomendaciones

A partir de la versión 15 de la API de Google Ads, puedes usar RecommendationSubscriptionService para aplicar automáticamente las recomendaciones de un tipo específico.

Para suscribirte a un tipo de recomendación específico, crea un objeto RecommendationSubscription, establece el campo type en uno de los tipos de recomendaciones admitidos y establece el campo status en ENABLED.

Tipos de recomendaciones compatibles con suscripciones

  • 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

Cómo recuperar suscripciones

Para obtener información sobre las suscripciones a recomendaciones de una cuenta, consulta el recurso recommendation_subscription.

Para ver los cambios que se aplicaron automáticamente, consulta el recurso change_event y filtra change_client_type por GOOGLE_ADS_RECOMMENDATIONS_SUBSCRIPTION.

Recomendaciones para la creación de campañas

A partir de la versión 16 de la API de Google Ads, puedes usar RecommendationService.GenerateRecommendationsRequest a fin de generar recomendaciones durante la creación de la campaña para un conjunto determinado de tipos de recomendaciones.

GenerateRecommendations acepta como entrada un ID de cliente, un tipo de canal de publicidad que debe ser SEARCH o PERFORMANCE_MAX, una lista de tipos de recomendaciones para generar y varios datos que dependen de los tipos especificados. Como resultado, se muestra una lista de objetos Recommendation basados en los datos que proporcionas. Si no hay datos suficientes para generar una recomendación para el recommendation_types solicitado, o si la campaña ya se encuentra en el estado recomendado, el conjunto de resultados no contendrá una recomendación para ese tipo. Asegúrate de que tu aplicación controle el caso en el que no se muestran recomendaciones para los tipos de recomendaciones solicitados.

En la siguiente tabla, se describen los tipos de recomendaciones que admite GenerateRecommendations y los campos que debes proporcionar para recibir recomendaciones de ese tipo. Como práctica recomendada, envía la solicitud GenerateRecommendations después de que se haya recopilado toda la información relacionada con los tipos de recomendaciones solicitados. Para obtener detalles adicionales sobre los campos obligatorios y opcionales, incluidos los campos anidados, consulta la documentación de referencia.

RecommendationType Campos obligatorios Campos opcionales
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
Nota: El objeto SitelinkAssetRecommendation que se muestra contendrá listas vacías. Si la respuesta GenerateRecommendations contiene un SitelinkAssetRecommendation, se puede tratar como un indicador para agregar al menos un recurso de vínculo a sitio a la campaña.
  • campaign_sitelink_count
TARGET_CPA_OPT_IN
  • conversion_tracking_status
  • bidding_info
TARGET_ROAS_OPT_IN
  • conversion_tracking_status
  • bidding_info

Ejemplo de flujo de uso

Supongamos que tu empresa es una agencia de publicidad que proporciona a los usuarios un flujo de trabajo de creación de campañas y deseas ofrecer sugerencias a los usuarios durante ese flujo. Puedes usar GenerateRecommendationsRequest para generar recomendaciones a pedido y, luego, incorporarlas a la interfaz de usuario de creación de la campaña.

El flujo de uso podría verse de la siguiente manera:

  1. Un usuario accede a tu aplicación para crear una campaña de máximo rendimiento.

  2. El usuario proporciona información inicial como parte del flujo de creación de la campaña. Por ejemplo, proporcionan detalles para crear una sola SitelinkAsset y seleccionan TARGET_SPEND como su estrategia de Ofertas inteligentes.

  3. Debes enviar un GenerateRecommendationsRequest que establece los siguientes campos:

    • campaign_sitelink_count: Se establece en 1, que es la cantidad de recursos de vínculos a sitios en la campaña en curso.

    • bidding_info: Establece el campo bidding_strategy_type anidado en TARGET_SPEND.

    • conversion_tracking_status: Se establece en el ConversionTrackingStatus de este cliente. Consulta la guía de introducción para recuperar este campo y administrar las conversiones.

    • recommendation_types: establecido como [SITELINK_ASSET, MAXIMIZE_CLICKS_OPT_IN].

    • advertising_channel_type: establecido como PERFORMANCE_MAX.

    • customer_id: Se establece en el ID del cliente que crea la campaña.

  4. Puedes tomar las recomendaciones en el GenerateRecommendationsResponse (en este caso, un SitelinkAssetRecommendation y un MaximizeClicksOptInRecommendation) y sugerirlas al usuario mostrándolas dentro de la interfaz de creación de tu campaña. Si el usuario acepta una sugerencia, puedes incorporarla a la solicitud de creación de la campaña una vez que complete el flujo de creación de la campaña.