Elementos en una campaña de máximo rendimiento

Las campañas de máximo rendimiento tienen algunas características únicas en relación con los recursos.

1. Hay una cantidad mínima obligatoria de recursos de diferentes tipos.
2. Los recursos se agrupan en una colección llamada AssetGroup, que es exclusiva de las campañas de máximo rendimiento.
3. Algunos recursos se pueden generar automáticamente con el aprendizaje automático.

Punto clave: Descubre cómo crear recursos con la guía interactiva para las campañas de máximo rendimiento.

Sugerencia: Si actualizas a campañas de máximo rendimiento desde otros tipos de campañas, puedes volver a utilizar tus recursos existentes en la cuenta de Google Ads. Consulta la guía de actualización para obtener detalles sobre los recursos adicionales que debes agregar.

Ejemplo de código

En el siguiente fragmento de código, se ilustra cómo crear los recursos repetidos necesarios en una solicitud nueva:

Java

/** Creates multiple text assets and returns the list of resource names. */
private List<String> createMultipleTextAssets(
    GoogleAdsClient googleAdsClient, long customerId, List<String> texts) {
  List<MutateOperation> mutateOperations = new ArrayList<>();
  for (String text : texts) {
    Asset asset = Asset.newBuilder().setTextAsset(TextAsset.newBuilder().setText(text)).build();
    AssetOperation assetOperation = AssetOperation.newBuilder().setCreate(asset).build();
    mutateOperations.add(MutateOperation.newBuilder().setAssetOperation(assetOperation).build());
  }

  List<String> assetResourceNames = new ArrayList<>();
  // Creates the service client.
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    // Sends the operations in a single Mutate request.
    MutateGoogleAdsResponse response =
        googleAdsServiceClient.mutate(Long.toString(customerId), mutateOperations);
    for (MutateOperationResponse result : response.getMutateOperationResponsesList()) {
      if (result.hasAssetResult()) {
        assetResourceNames.add(result.getAssetResult().getResourceName());
      }
    }
    printResponseDetails(response);
  }
  return assetResourceNames;
}
AddPerformanceMaxCampaign.java
      

C#

/// <summary>
/// Creates multiple text assets and returns the list of resource names.
/// </summary>
/// <param name="client">The Google Ads Client.</param>
/// <param name="customerId">The customer's ID.</param>
/// <param name="texts">The texts to add.</param>
/// <returns>A list of asset resource names.</returns>
private List<string> CreateMultipleTextAssets(
    GoogleAdsClient client,
    long customerId,
    string[] texts)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsServiceClient =
        client.GetService(Services.V19.GoogleAdsService);

    MutateGoogleAdsRequest request = new MutateGoogleAdsRequest()
    {
        CustomerId = customerId.ToString()
    };

    foreach (string text in texts)
    {
        request.MutateOperations.Add(
            new MutateOperation()
            {
                AssetOperation = new AssetOperation()
                {
                    Create = new Asset()
                    {
                        TextAsset = new TextAsset()
                        {
                            Text = text
                        }
                    }
                }
            }
        );
    }

    // Send the operations in a single Mutate request.
    MutateGoogleAdsResponse response = googleAdsServiceClient.Mutate(request);

    List<string> assetResourceNames = new List<string>();

    foreach (MutateOperationResponse operationResponse in response.MutateOperationResponses)
    {
        MutateAssetResult assetResult = operationResponse.AssetResult;
        assetResourceNames.Add(assetResult.ResourceName);
    }

    PrintResponseDetails(response);

    return assetResourceNames;
}
AddPerformanceMaxCampaign.cs
      

PHP

private static function createMultipleTextAssets(
    GoogleAdsClient $googleAdsClient,
    int $customerId,
    array $texts
): array {
    // Here again, we use the GoogleAdService to create multiple text assets in a single
    // request.
    $operations = [];
    foreach ($texts as $text) {
        // Creates a mutate operation for a text asset.
        $operations[] = new MutateOperation([
            'asset_operation' => new AssetOperation([
                'create' => new Asset(['text_asset' => new TextAsset(['text' => $text])])
            ])
        ]);
    }

    // Issues a mutate request to add all assets.
    $googleAdsService = $googleAdsClient->getGoogleAdsServiceClient();
    /** @var MutateGoogleAdsResponse $mutateGoogleAdsResponse */
    $mutateGoogleAdsResponse =
        $googleAdsService->mutate(MutateGoogleAdsRequest::build($customerId, $operations));

    $assetResourceNames = [];
    foreach ($mutateGoogleAdsResponse->getMutateOperationResponses() as $response) {
        /** @var MutateOperationResponse $response */
        $assetResourceNames[] = $response->getAssetResult()->getResourceName();
    }
    self::printResponseDetails($mutateGoogleAdsResponse);

    return $assetResourceNames;
}
AddPerformanceMaxCampaign.php
      

Python

def create_multiple_text_assets(client, customer_id, texts):
    """Creates multiple text assets and returns the list of resource names.

    Args:
        client: an initialized GoogleAdsClient instance.
        customer_id: a client customer ID.
        texts: a list of strings, each of which will be used to create a text
          asset.

    Returns:
        asset_resource_names: a list of asset resource names.
    """
    # Here again we use the GoogleAdService to create multiple text
    # assets in a single request.
    googleads_service = client.get_service("GoogleAdsService")

    operations = []
    for text in texts:
        mutate_operation = client.get_type("MutateOperation")
        asset = mutate_operation.asset_operation.create
        asset.text_asset.text = text
        operations.append(mutate_operation)

    # Send the operations in a single Mutate request.
    response = googleads_service.mutate(
        customer_id=customer_id,
        mutate_operations=operations,
    )
    asset_resource_names = []
    for result in response.mutate_operation_responses:
        if result._pb.HasField("asset_result"):
            asset_resource_names.append(result.asset_result.resource_name)
    print_response_details(response)
    return asset_resource_names
add_performance_max_campaign.py
      

Ruby

# Creates multiple text assets and returns the list of resource names.
def create_multiple_text_assets(client, customer_id, texts)
  operations = texts.map do |text|
    client.operation.mutate do |m|
      m.asset_operation = client.operation.create_resource.asset do |asset|
        asset.text_asset = client.resource.text_asset do |text_asset|
          text_asset.text = text
        end
      end
    end
  end

  # Send the operations in a single Mutate request.
  response = client.service.google_ads.mutate(
    customer_id: customer_id,
    mutate_operations: operations,
  )

  asset_resource_names = []
  response.mutate_operation_responses.each do |result|
    if result.asset_result
      asset_resource_names.append(result.asset_result.resource_name)
    end
  end
  print_response_details(response)
  asset_resource_names
end
add_performance_max_campaign.rb
      

Perl

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

  # Here again we use the GoogleAdService to create multiple text assets in a
  # single request.
  my $operations = [];
  foreach my $text (@$texts) {
    # Create a mutate operation for a text asset.
    push @$operations,
      Google::Ads::GoogleAds::V19::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V19::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V19::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V19::Common::TextAsset->new({
                    text => $text
                  })})})});
  }

  # Issue a mutate request to add all assets.
  my $mutate_google_ads_response = $api_client->GoogleAdsService()->mutate({
    customerId       => $customer_id,
    mutateOperations => $operations
  });

  my $asset_resource_names = [];
  foreach
    my $response (@{$mutate_google_ads_response->{mutateOperationResponses}})
  {
    push @$asset_resource_names, $response->{assetResult}{resourceName};
  }
  print_response_details($mutate_google_ads_response);

  return $asset_resource_names;
}
add_performance_max_campaign.pl
      

Elementos creados automáticamente

La automatización de Google con el aprendizaje automático genera recursos adicionales según sea necesario para abarcar todos los canales relevantes. Los recursos se mezclan y combinan automáticamente en función del canal publicitario de Google (como YouTube, Gmail o la Búsqueda) en el que se publica tu anuncio.

Recursos de texto

Puedes asociar un feed de páginas en tu cuenta con una campaña de máximo rendimiento para generar recursos automáticamente.

Para vincular un feed de páginas con una campaña, sigue el mismo proceso que se usa para los anuncios dinámicos de búsqueda:

1. Crea recursos para cada página de tu sitio web
2. Cómo empaquetar recursos de un feed de páginas en un AssetSet
3. Asigna el conjunto de recursos a una campaña

Después de asociar un feed de páginas, asegúrate de que el elemento AssetAutomationSetting de tipo TEXT_ASSET_AUTOMATION esté configurado como OPTED_IN. Este es el parámetro de configuración predeterminado si no estableciste AssetAutomationSetting cuando creaste la campaña.

Si utilizas este parámetro de configuración, tu campaña podrá usar el contenido de tu página de destino, el dominio y los recursos proporcionados para personalizar los anuncios cuando se prevea que mejorarán el rendimiento. Te recomendamos que lo dejes como OPTED-IN.

Punto clave: Para que esta función funcione, deben estar presentes el CampaignAssetSet para AssetSet de tipo PAGE_FEED y TEXT_ASSET_AUTOMATION establecido en OPTED_IN (o no se debe establecer AssetAutomationSetting para TEXT_ASSET_AUTOMATION). Si quieres establecer TEXT_ASSET_AUTOMATION en OPTED_OUT, primero debes quitar CampaignAssetSet antes de cambiar AssetAutomationSetting. Lo mismo sucede al revés: debes habilitar TEXT_ASSET_AUTOMATION antes de crear un CampaignAssetSet. Si intentas configurar uno de estos sin el otro, se generará un error OPERATION_NOT_PERMITTED_FOR_CONTEXT.

Recursos de video

Si no agregas un video a tu grupo de recursos de la campaña de máximo rendimiento, es posible que se generen uno o más recursos de video a partir de los recursos de tu grupo. Si ya no deseas que los videos generados automáticamente se publiquen en tu campaña de máximo rendimiento, puedes subir tu propio video personalizado, y los videos generados automáticamente dejarán de publicarse.

La automatización inteligente puede mejorar tus recursos de video de YouTube ajustando la orientación del video y acortándolo de forma inteligente para destacar los momentos clave. Si prefieres mantener tus recursos de video originales, establece el AssetAutomationSetting de tipo GENERATE_ENHANCED_YOUTUBE_VIDEOS en OPTED_OUT.