Elementos en una campaña de máximo rendimiento

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Las campañas de máximo rendimiento tienen algunas características únicas con respecto a los elementos.

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

Asegúrese de que se cumplan los requisitos mínimos de los elementos

Cada campaña de máximo rendimiento requiere un conjunto mínimo de elementos. Estos pueden ser elementos existentes que se usan en otras campañas o elementos nuevos específicos para una campaña de máximo rendimiento.

Tipo de recurso Tipo de campo Especificaciones Mín Máx
TEXTO HEADLINE Máximo de 30 caracteres; incluye al menos uno con 15 caracteres o menos. 3 5
LONG_HEADLINE Máximo de 90 caracteres 1 5
DESCRIPCIÓN Máximo de 90 caracteres; incluye, al menos, uno con 60 caracteres o menos. 2 5
BUSINESS_NAME Utilice 25 caracteres, como máximo. 1 1
IMAGE MARKETING_IMAGE Horizontal (1.91:1): Se recomienda 1,200 x 628; 600 x 314 como mínimo; 5,120 KB de tamaño máximo del archivo. 1 20
SQUARE_MARKETING_IMAGE (1:1) Se recomienda 1,200 x 1,200; 300 x 300 como mínimo; 5,120 KB de tamaño máximo del archivo. 1 20
PORTRAIT_MARKETING_IMAGE (4:5) Se recomienda 960 x 1,200; 480 x 600 como mínimo 0 20
LOGO (1:1) Se recomienda 1,200 x 1,200. Tamaño máximo del archivo: 128 x 128; 5,120 KB 1 5
LANDSCAPE_LOGO (4:1) Se recomienda 1,200 x 300; 512 x 128 como mínimo; 5,120 KB de tamaño máximo del archivo. 0 5
VIDEO_DE_YOUTUBE VIDEO_DE_YOUTUBE horizontal, vertical o cuadrado; duración de 10 segundos o mayor 0 5
LLAMADA A LA ACCIÓN CALL_TO_ACTION_SELECTION Automática o predeterminada de una lista 0 1
PAQUETE DE MEDIA. PAQUETE DE MEDIA. <150 KB 0 1

Los recursos repetidos (HEADLINE, DESCRIPTION) deben crearse en una solicitud separada antes de crear la campaña.

En el siguiente fragmento de código, se ilustra la creación de los elementos 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;
}
      

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

      

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($customerId, $operations);

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

    return $assetResourceNames;
}
      

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
      

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
      

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::V13::Services::GoogleAdsService::MutateOperation
      ->new({
        assetOperation =>
          Google::Ads::GoogleAds::V13::Services::AssetService::AssetOperation->
          new({
            create => Google::Ads::GoogleAds::V13::Resources::Asset->new({
                textAsset =>
                  Google::Ads::GoogleAds::V13::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;
}
      

Grupos de elementos

Cada campaña requiere, al menos, un grupo de elementos. Los elementos se mezclan y combinan automáticamente en función del canal publicitario de Google (YouTube, Gmail, la Búsqueda, etc.) en el que se publica su anuncio.

Elementos generados por la automatización

La automatización de Google mediante el aprendizaje automático genera elementos adicionales según sea necesario para abarcar todos los canales relevantes.

Si no agrega un video a su grupo de elementos de la campaña de máximo rendimiento, es posible que se generen uno o más elementos de video a partir de los elementos de su grupo. Si ya no desea que los videos generados automáticamente se publiquen en su campaña de máximo rendimiento, puede subir su propio video personalizado, y estos se dejarán de publicar.