Etiquetas

Las etiquetas te permiten clasificar tus campañas, grupos de anuncios, anuncios y palabras clave, y usar esas categorías para simplificar tu flujo de trabajo de varias maneras.

En esta guía, se describen los pasos necesarios para hacer lo siguiente:

• Crea etiquetas de manera programática con LabelService.
• Asigna etiquetas a tus campañas con las solicitudes CampaignLabelService.
• Recupera y filtra los resultados de los informes por etiqueta con las consultas de GoogleAdsService.

Esta guía se centra en las campañas, pero puedes usar el mismo enfoque para los grupos de anuncios, los anuncios y las palabras clave. Esta API también proporciona CustomerLabelService, que permite que las cuentas de administrador asignen etiquetas a las cuentas secundarias.

Casos de uso

Entre las situaciones típicas para usar etiquetas, se incluyen las siguientes:

• Tu cuenta tiene campañas que habilitas solo durante ciertas épocas del año y deseas incluirlas o excluirlas de los informes.
• Agregaste un conjunto nuevo de palabras clave a tu grupo de anuncios y quieres comparar sus estadísticas con las de otras palabras clave de tu grupo de anuncios.
• Cada uno de los usuarios de tu cuenta de Google Ads administra un subconjunto de campañas y quieres identificar el conjunto de campañas de cada usuario.
• Tu app necesita marcar el estado de ciertos objetos.

Crear etiquetas

Crea etiquetas con un objeto Label con su campo text_label establecido:

1. Crea una instancia de TextLabel que contenga un color de fondo y una descripción.
2. Crea una instancia de Label y asigna el TextLabel a su campo text_label.
3. Une el Label en un LabelOperation (create) y envíalo a LabelService.MutateLabels.

Toma nota del ID de la etiqueta creada para realizar consultas más adelante. El ID está incorporado en el campo resource_name de la MutateLabelResult que se devuelve en la MutateLabelsResponse.

También puedes usar una solicitud GoogleAdsService Search o SearchStream para recuperar los IDs de etiqueta y los nombres de recursos.

Asignar etiquetas

Puedes asignar etiquetas a tus campañas, clientes, grupos de anuncios, criterios o anuncios con la operación Mutate en el servicio correspondiente.

Por ejemplo, para asignar etiquetas a una campaña, pasa uno o más objetos CampaignLabelOperation a CampaignLabelService.MutateCampaignLabels. Cada CampaignLabelOperation incluye una instancia CampaignLabel, que requiere nombres de recursos completos en estos campos:

• label: Es el nombre del recurso de una etiqueta (por ejemplo, customers/{customer_id}/labels/{label_id}).
• campaign: Es el nombre del recurso de una campaña (por ejemplo, customers/{customer_id}/campaigns/{campaign_id}).

Crea una instancia de CampaignLabel para cada par de etiqueta y campaña. Encapsúlalo en un CampaignLabelOperation con la operación create y envíalo a CampaignLabelService.MutateCampaignLabels.

Cómo agregar etiquetas de campaña

Este es un ejemplo de código que muestra cómo agregar una etiqueta de campaña a una lista de campañas:

Java

private void runExample(
    GoogleAdsClient googleAdsClient, long customerId, List<Long> campaignIds, Long labelId) {
  // Gets the resource name of the label to be added across all given campaigns.
  String labelResourceName = ResourceNames.label(customerId, labelId);

  List<CampaignLabelOperation> operations = new ArrayList<>(campaignIds.size());
  // Creates a campaign label operation for each campaign.
  for (Long campaignId : campaignIds) {
    // Gets the resource name of the given campaign.
    String campaignResourceName = ResourceNames.campaign(customerId, campaignId);
    // Creates the campaign label.
    CampaignLabel campaignLabel =
        CampaignLabel.newBuilder()
            .setCampaign(campaignResourceName)
            .setLabel(labelResourceName)
            .build();

    operations.add(CampaignLabelOperation.newBuilder().setCreate(campaignLabel).build());
  }

  try (CampaignLabelServiceClient campaignLabelServiceClient =
      googleAdsClient.getLatestVersion().createCampaignLabelServiceClient()) {
    MutateCampaignLabelsResponse response =
        campaignLabelServiceClient.mutateCampaignLabels(Long.toString(customerId), operations);
    System.out.printf("Added %d campaign labels:%n", response.getResultsCount());
    for (MutateCampaignLabelResult result : response.getResultsList()) {
      System.out.println(result.getResourceName());
    }
  }
}
AddCampaignLabels.java
      

C#

public void Run(GoogleAdsClient client, long customerId, long[] campaignIds, long labelId)
{
    // Get the CampaignLabelServiceClient.
    CampaignLabelServiceClient campaignLabelService =
        client.GetService(Services.V26.CampaignLabelService);

    // Gets the resource name of the label to be added across all given campaigns.
    string labelResourceName = ResourceNames.Label(customerId, labelId);

    List<CampaignLabelOperation> operations = new List<CampaignLabelOperation>();
    // Creates a campaign label operation for each campaign.
    foreach (long campaignId in campaignIds)
    {
        // Gets the resource name of the given campaign.
        string campaignResourceName = ResourceNames.Campaign(customerId, campaignId);
        // Creates the campaign label.
        CampaignLabel campaignLabel = new CampaignLabel()
        {
            Campaign = campaignResourceName,
            Label = labelResourceName
        };

        operations.Add(new CampaignLabelOperation()
        {
            Create = campaignLabel
        });
    }

    // Send the operation in a mutate request.
    try
    {
        MutateCampaignLabelsResponse response =
            campaignLabelService.MutateCampaignLabels(customerId.ToString(), operations);
        Console.WriteLine($"Added {response.Results} campaign labels:");

        foreach (MutateCampaignLabelResult 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;
    }
}
AddCampaignLabels.cs
      

PHP

    public static function runExample(
        GoogleAdsClient $googleAdsClient,
        int $customerId,
        array $campaignIds,
        int $labelId
    ) {
        // Gets the resource name of the label to be added across all given campaigns.
        $labelResourceName = ResourceNames::forLabel($customerId, $labelId);

        // Creates a campaign label operation for each campaign.
        $operations = [];
        foreach ($campaignIds as $campaignId) {
            // Creates the campaign label.
            $campaignLabel = new CampaignLabel(
                [
                'campaign' => ResourceNames::forCampaign($customerId, $campaignId),
                'label' => $labelResourceName
                ]
            );
            $campaignLabelOperation = new CampaignLabelOperation();
            $campaignLabelOperation->setCreate($campaignLabel);
            $operations[] = $campaignLabelOperation;
        }

        // Issues a mutate request to add the labels to the campaigns.
        $campaignLabelServiceClient = $googleAdsClient->getCampaignLabelServiceClient();
        $response = $campaignLabelServiceClient->mutateCampaignLabels(
            MutateCampaignLabelsRequest::build($customerId, $operations)
        );

        printf("Added %d campaign labels:%s", $response->getResults()->count(), PHP_EOL);

        foreach ($response->getResults() as $addedCampaignLabel) {
            /**
 * @var CampaignLabel $addedCampaignLabel
*/
            printf(
                "New campaign label added with resource name: '%s'.%s",
                $addedCampaignLabel->getResourceName(),
                PHP_EOL
            );
        }
    }
AddCampaignLabels.php
      

Python

def main(
    client: GoogleAdsClient,
    customer_id: str,
    label_id: str,
    campaign_ids: List[str],
) -> None:
    """This code example adds a campaign label to a list of campaigns.

    Args:
        client: An initialized GoogleAdsClient instance.
        customer_id: A client customer ID str.
        label_id: The ID of the label to attach to campaigns.
        campaign_ids: A list of campaign IDs to which the label will be added.
    """

    # Get an instance of CampaignLabelService client.
    campaign_label_service: CampaignLabelServiceClient = client.get_service(
        "CampaignLabelService"
    )
    campaign_service: CampaignServiceClient = client.get_service(
        "CampaignService"
    )
    label_service: LabelServiceClient = client.get_service("LabelService")

    # Build the resource name of the label to be added across the campaigns.
    label_resource_name: str = label_service.label_path(customer_id, label_id)

    operations: List[Any] = []

    for campaign_id in campaign_ids:
        campaign_resource_name: str = campaign_service.campaign_path(
            customer_id, campaign_id
        )
        campaign_label_operation: Any = client.get_type(
            "CampaignLabelOperation"
        )

        campaign_label: CampaignLabel = campaign_label_operation.create
        campaign_label.campaign = campaign_resource_name
        campaign_label.label = label_resource_name
        operations.append(campaign_label_operation)

    response: MutateCampaignLabelsResponse = (
        campaign_label_service.mutate_campaign_labels(
            customer_id=customer_id, operations=operations
        )
    )
    print(f"Added {len(response.results)} campaign labels:")
    for result in response.results:
        print(result.resource_name)
add_campaign_labels.py
      

Ruby

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

  label_resource_name = client.path.label(customer_id, label_id)

  labels = campaign_ids.map { |campaign_id|
    client.resource.campaign_label do |label|
      campaign_resource_name = client.path.campaign(customer_id, campaign_id)
      label.campaign = campaign_resource_name
      label.label = label_resource_name
    end
  }

  ops = labels.map { |label|
    client.operation.create_resource.campaign_label(label)
  }

  response = client.service.campaign_label.mutate_campaign_labels(
    customer_id: customer_id,
    operations: ops,
  )
  response.results.each do |result|
    puts("Created campaign label with id: #{result.resource_name}")
  end
end
add_campaign_labels.rb
      

Perl

sub add_campaign_labels {
  my ($api_client, $customer_id, $campaign_ids, $label_id) = @_;

  my $label_resource_name =
    Google::Ads::GoogleAds::V26::Utils::ResourceNames::label($customer_id,
    $label_id);

  my $campaign_label_operations = [];

  # Create a campaign label operation for each campaign.
  foreach my $campaign_id (@$campaign_ids) {
    # Create a campaign label.
    my $campaign_label =
      Google::Ads::GoogleAds::V26::Resources::CampaignLabel->new({
        campaign => Google::Ads::GoogleAds::V26::Utils::ResourceNames::campaign(
          $customer_id, $campaign_id
        ),
        label => $label_resource_name
      });

    # Create a campaign label operation.
    my $campaign_label_operation =
      Google::Ads::GoogleAds::V26::Services::CampaignLabelService::CampaignLabelOperation
      ->new({
        create => $campaign_label
      });

    push @$campaign_label_operations, $campaign_label_operation;
  }

  # Add the campaign labels to the campaigns.
  my $campaign_labels_response = $api_client->CampaignLabelService()->mutate({
    customerId => $customer_id,
    operations => $campaign_label_operations
  });

  my $campaign_label_results = $campaign_labels_response->{results};
  printf "Added %d campaign labels:\n", scalar @$campaign_label_results;

  foreach my $campaign_label_result (@$campaign_label_results) {
    printf "Created campaign label '%s'.\n",
      $campaign_label_result->{resourceName};
  }

  return 1;
}
add_campaign_labels.pl
      

curl

Nota: Aunque aquí no se proporciona una muestra de código de REST directa para este paso, puedes lograrlo con una solicitud de REST manual.

Consulta la documentación de la interfaz de REST de la API de Google Ads y las páginas de referencia específicas de cada método. Deberás construir la carga útil de JSON según las definiciones de proto.

Recursos clave:

• Usa REST
• Estructura de la interfaz de REST
• Asignaciones de campos JSON
• Consulta la referencia de la API de REST para conocer el servicio y el método específicos.

Cómo asignar etiquetas a los clientes

Asignar etiquetas a un cliente es una tarea común para las cuentas de administrador con el objetivo de categorizar sus cuentas de cliente. Esto se realiza con CustomerLabelService. Las etiquetas creadas por una cuenta de administrador son propiedad de esa cuenta y solo se pueden ver cuando se autentica como la cuenta de administrador propietaria.

Cada CustomerLabelOperation incluye una instancia de CustomerLabel. Cuando crees una relación entre cliente y etiqueta, ten en cuenta lo siguiente:

• label: Este campo es obligatorio y debe ser el nombre del recurso de una etiqueta que pertenezca a la cuenta de administrador, como customers/{MANAGER_ID}/labels/{LABEL_ID}.
• customer: Este campo es solo de salida y no se debe establecer en la solicitud. El cliente que se etiqueta se determina por el customer_id en la ruta de acceso MutateCustomerLabelsRequest.

Nota: Un solo MutateCustomerLabelsRequest solo puede modificar las etiquetas de la cuenta de cliente única especificada en la solicitud. Para aplicar una etiqueta a varias cuentas de cliente, debes realizar llamadas a la API independientes para cada cuenta.

Recupera objetos con sus etiquetas

Después de asignar etiquetas a tus campañas, puedes usar los campos de etiqueta para recuperar objetos por ID.

Pasa una consulta de GAQL adecuada a una solicitud Search o SearchStream de GoogleAdsService. Por ejemplo, la siguiente consulta devuelve el ID, el nombre y las etiquetas de cada campaña asociada con cualquiera de los tres IDs de etiqueta:

SELECT
  campaign.id,
  campaign.name,
  label.id,
  label.name
FROM campaign_label
WHERE label.id IN (123456, 789012, 345678)

Solo puedes filtrar por ID de etiqueta, no por nombre de etiqueta. Para obtener el ID de la etiqueta a partir de su nombre, usa esta consulta:

SELECT
  label.id,
  label.name
FROM label
WHERE label.name = "LABEL_NAME"

Recupera las etiquetas aplicadas a un cliente

Cuando obtienes la jerarquía de cuentas en una cuenta de administrador, puedes recuperar la lista de etiquetas aplicadas a una cuenta de cliente secundaria solicitando el campo applied_labels del objeto CustomerClient. Este campo recupera solo las etiquetas que pertenecen al cliente que realiza la llamada a la API.

Usa etiquetas en los informes

Usa etiquetas para mejorar la utilidad de tus informes.

Informes de etiquetas

El recurso de informe Label devuelve detalles sobre las etiquetas definidas en una cuenta. Los detalles incluyen el nombre, el ID, el nombre del recurso, el estado, el color de fondo y la descripción, así como el recurso Cliente que representa al propietario de la etiqueta.

Informes con métricas

Las vistas de informes Ad Group y Campaign contienen el campo labels. El servicio de informes devuelve los nombres de los recursos de etiqueta en el formato customers/{customer_id}/labels/{label_id}. Por ejemplo, el nombre del recurso customers/123456789/labels/012345 hace referencia a la etiqueta con el ID 012345 en la cuenta con el ID 123456789.

Informes sin métricas

Cada uno de los siguientes recursos de informes se puede usar para encontrar relaciones entre recursos y etiquetas:

• Etiqueta de anuncio del grupo de anuncios
• Etiqueta de criterio del grupo de anuncios
• Etiqueta del grupo de anuncios
• Etiqueta de la campaña
• Etiqueta de cliente

Puedes filtrar estos resultados del informe comparando el campo label.id con cualquier operador de comparación numérico o los operadores BETWEEN, IS NULL, IS NOT NULL, IN o NOT IN.

En este ejemplo, puedes obtener todas las campañas con un ID de etiqueta específico:

SELECT
  campaign.id,
  campaign.name,
  label.id,
  label.name
FROM campaign_label
WHERE label.id = LABEL_ID
ORDER BY campaign.id