Etiquetas

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

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

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

Casos de uso

Las situaciones típicas para usar etiquetas incluyen las siguientes:

  • Tu cuenta tiene campañas que habilitas solo durante ciertas épocas del año, y deseas incluir o excluir fácilmente esas campañas de los informes.
  • Agregó un nuevo conjunto de palabras clave a su grupo de anuncios y desea comparar sus estadísticas con otras palabras clave de su grupo de anuncios.
  • Cada usuario de tu cuenta de Google Ads administra un subconjunto de campañas y deseas identificar el conjunto de campañas para cada uno de ellos.
  • Tu app necesita marcar el estado de ciertos objetos.

Crea etiquetas

Crea etiquetas con el objeto TextLabel:

  1. Crea una instancia de TextLabel.
  2. Establece un color de fondo para este elemento TextLabel.
  3. Ingresa el texto para este TextLabel usando el campo de descripción.
  4. Une el TextLabel en un LabelOperation y envíalo a LabelService.MutateLabels.

Toma nota de los IDs de las nuevas etiquetas para consultas posteriores. Los ID están incorporados en el campo resource_name del MutateLabelResults que se muestra en MutateLabelsResponse.

También puedes usar una solicitud LabelService.GetLabel o una solicitud GoogleAdsService, Search o SearchStream para recuperar los IDs.

Asignar etiquetas

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

Por ejemplo, para asignar etiquetas a una campaña, pasa uno o más CampaignLabelOperation a CampaignLabelService.MutateCampaignLabels. Cada CampaignLabelOperation incluye una instancia de CampaignLabel, que contiene los siguientes campos:

  • label: ID de una etiqueta
  • campaign: ID de una campaña

Crea una instancia de CampaignLabel para cada par de etiquetas y campañas. Úsalo en un CampaignLabelOperation con la operación create y envíalo a CampaignService.MutateCampaignLabels.

Agregar etiquetas de campaña

A continuación, se incluye 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());
    }
  }
}
      

C#

public void Run(GoogleAdsClient client, long customerId, long[] campaignIds, long labelId)
{
    // Get the CampaignLabelServiceClient.
    CampaignLabelServiceClient campaignLabelService =
        client.GetService(Services.V15.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;
    }
}
      

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

Python

def main(client, customer_id, label_id, campaign_ids):
    """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 = client.get_service("CampaignLabelService")
    campaign_service = client.get_service("CampaignService")
    label_service = client.get_service("LabelService")

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

    operations = []

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

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

    response = 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)
      

Rita

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
      

Perl

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

  my $label_resource_name =
    Google::Ads::GoogleAds::V15::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::V15::Resources::CampaignLabel->new({
        campaign => Google::Ads::GoogleAds::V15::Utils::ResourceNames::campaign(
          $customer_id, $campaign_id
        ),
        label => $label_resource_name
      });

    # Create a campaign label operation.
    my $campaign_label_operation =
      Google::Ads::GoogleAds::V15::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;
}
      

Recupera objetos con sus etiquetas

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

Pasa una consulta de GAQL adecuada a una solicitud GoogleAdsService Search o SearchStream. Por ejemplo, la siguiente consulta muestra el ID, el nombre y las etiquetas de cada campaña asociada con uno 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)

Ten en cuenta que solo puedes filtrar por ID de etiqueta, no por nombre de etiqueta. Para obtener el ID de una etiqueta de un nombre, puedes usar 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 si solicitas el campo applied_labels del objeto CustomerClient. Este campo recupera solo las etiquetas que pertenecen al cliente que realiza la llamada a la API.

Cómo usar etiquetas en los informes

Informes de etiquetas

El recurso de informe Etiqueta (Label) muestra 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 Customer que representa al propietario de la etiqueta.

Informes con métricas

Las vistas de los informes Grupo de anuncios y Campaña contienen el campo labels. El servicio de informes muestra los nombres de los recursos de etiquetas con 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 los recursos y las etiquetas:

Puedes filtrar los resultados del informe anterior 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.

Por ejemplo, puedes obtener todas las campañas con un ID de etiqueta específico de la siguiente manera:

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