Etiquetas

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

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

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

Casos de uso

Situaciones típicas para usar Las etiquetas de recursos incluyen lo siguiente:

  • Su cuenta tiene campañas que habilita solo en determinadas é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 a otras palabras clave de su grupo de anuncios.
  • Cada usuario de su cuenta de Google Ads administra un subconjunto de campañas, y usted desea una forma de identificar el conjunto de campañas de cada usuario.
  • Tu app necesita marcar el estado de ciertos objetos.

Crear etiquetas

Crea etiquetas con el objeto TextLabel:

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

Toma nota de las nuevas etiquetas IDs para consultas posteriores. Los IDs están incorporados en el resource_name en el Se muestran MutateLabelResults en el MutateLabelsResponse

También puedes usar una solicitud LabelService.GetLabel o un objeto GoogleAdsService Search o SearchStream para recuperar los ID.

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 una o más CampaignLabelOperation a CampaignLabelService.MutateCampaignLabels Cada CampaignLabelOperation incluye un CampaignLabel, que contiene estas campos:

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

Crea una instancia de CampaignLabel para cada par de etiqueta-campaña. Envuélvelo en un CampaignLabelOperation con la operación create y envíala a CampaignService.MutateCampaignLabels

Agregar etiquetas de campaña

A continuación, presentamos 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.V17.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, 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)
add_campaign_labels.py

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

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

Recupera objetos con sus etiquetas

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

Pasa una consulta de GAQL adecuada a una GoogleAdsService Search o SearchStream para cada solicitud. 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)

Ten en cuenta que solo puedes filtrar por ID de etiqueta, no por nombre de etiqueta. Para obtener el ID de la etiqueta desde el nombre de una etiqueta, 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 bajo un administrador , puedes recuperar la lista de etiquetas aplicadas a una cuenta de cliente secundario solicitando la applied_labels del CustomerClient. Este campo recupera solo las etiquetas que son propiedad del cliente que realiza la llamada a la API.

Cómo usar etiquetas en los informes

Informes de etiquetas

El recurso de informe Etiqueta muestra los detalles de las etiquetas. definidos 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 la información sobre el atributo Customer recurso que representa al propietario de la etiqueta.

Informes con métricas

Los informes Grupo de anuncios y Campaña contienen el campo labels. El servicio de informes devuelve la etiqueta nombres de recursos en el formato customers/{customer_id}/labels/{label_id}. Para ejemplo, el nombre de recurso customers/123456789/labels/012345 hace referencia al 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 buscar relaciones recursos y etiquetas de recurso:

Puede filtrar los resultados del informe anterior comparando el campo label.id con las siguientes opciones: cualquier operador de comparación numérico o los operadores BETWEEN, IS NULL, IS NOT NULL, IN o NOT IN.

A modo de 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
Anterior
Cero métricas
Siguiente
Transmisión