Rótulos

Com os rótulos, você pode categorizar suas campanhas, grupos de anúncios, anúncios e palavras-chave e usar essas categorias para simplificar seu fluxo de trabalho de várias maneiras.

Este guia explica os passos necessários para:

• Crie rótulos de maneira programática usando LabelService.
• Atribua rótulos às suas campanhas usando solicitações CampaignLabelService.
• Recupere e filtre os resultados do relatório por rótulo usando consultas GoogleAdsService.

Este guia se concentra em campanhas, mas você pode usar a mesma abordagem para grupos de anúncios, anúncios e palavras-chave. Essa API também fornece CustomerLabelService, que permite que as contas de administrador atribuam rótulos às contas secundárias.

Casos de uso

Os cenários comuns para usar rótulos incluem o seguinte:

• Sua conta tem campanhas que você ativa apenas em determinadas épocas do ano, e você quer incluir ou excluir essas campanhas dos relatórios.
• Você adicionou um novo conjunto de palavras-chave ao seu grupo de anúncios e quer comparar as estatísticas delas com as de outras palavras-chave no grupo.
• Os usuários da sua conta do Google Ads gerenciam um subconjunto de campanhas, e você quer uma maneira de identificar o conjunto de campanhas de cada usuário.
• O app precisa marcar o status de determinados objetos.

Criar marcadores

Crie rótulos usando um objeto Label com o campo text_label definido:

1. Crie uma instância TextLabel que contenha uma cor de fundo e uma descrição.
2. Crie uma instância Label e atribua o TextLabel ao campo text_label.
3. Encapsule o Label em um LabelOperation (create) e envie-o para LabelService.MutateLabels.

Anote o ID do rótulo criado para consultas futuras. O ID está incorporado no campo resource_name no MutateLabelResult retornado no MutateLabelsResponse.

Também é possível usar uma solicitação GoogleAdsService Search ou SearchStream para recuperar IDs de rótulos e nomes de recursos.

Atribuir rótulos

É possível atribuir rótulos a campanhas, clientes, grupos de anúncios, critérios ou anúncios usando a operação Mutate no serviço correspondente.

Por exemplo, para atribuir rótulos a uma campanha, transmita um ou mais objetos CampaignLabelOperation para CampaignLabelService.MutateCampaignLabels. Cada CampaignLabelOperation inclui uma instância CampaignLabel, que exige nomes de recursos completos nestes campos:

• label: nome do recurso de um rótulo (por exemplo, customers/{customer_id}/labels/{label_id}).
• campaign: nome do recurso de uma campanha (por exemplo, customers/{customer_id}/campaigns/{campaign_id}).

Crie uma instância de CampaignLabel para cada par de rótulo e campanha. Envolva-o em um CampaignLabelOperation com a operação create e envie-o para CampaignLabelService.MutateCampaignLabels.

Adicionar rótulos de campanha

Veja um exemplo de código que mostra como adicionar um rótulo de campanha a uma lista de campanhas:

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

Observação: embora não seja fornecido um exemplo de código REST direto para esta etapa, é possível fazer isso usando uma solicitação REST manual.

Consulte a documentação da interface REST da API Google Ads e as páginas de referência específicas do método. Você precisará criar o payload JSON com base nas definições de proto.

Principais recursos:

• Como usar REST
• Estrutura da interface REST
• Mapeamentos de campos JSON
• Consulte a Referência da API REST para o serviço e o método específicos.

Atribuir marcadores aos clientes

Atribuir rótulos a um cliente é uma tarefa comum para as contas de administrador categorizarem as contas de cliente. Isso é feito usando CustomerLabelService. Os rótulos criados por uma conta de administrador pertencem a ela e só ficam visíveis quando você faz login nessa conta.

Cada CustomerLabelOperation inclui uma instância de CustomerLabel. Ao criar uma relação entre cliente e marcador, lembre-se:

• label: esse campo é obrigatório e precisa ser o nome do recurso de um rótulo da conta de administrador, como customers/{MANAGER_ID}/labels/{LABEL_ID}.
• customer: este campo é somente para saída e não deve ser definido na solicitação. O cliente que está sendo rotulado é determinado pelo customer_id no caminho MutateCustomerLabelsRequest.

Observação: um único MutateCustomerLabelsRequest só pode modificar rótulos para a conta de cliente especificada na solicitação. Para aplicar um rótulo a várias contas de cliente, faça chamadas de API separadas para cada conta.

Recuperar objetos usando rótulos

Depois de atribuir rótulos às suas campanhas, use os campos de rótulo para recuperar objetos por ID.

Transmita uma consulta GAQL adequada para uma solicitação GoogleAdsService Search ou SearchStream. Por exemplo, a consulta a seguir retorna o ID, o nome e os rótulos de cada campanha associada a um dos três IDs de rótulo:

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

Só é possível filtrar por ID do rótulo, não por nome. Para receber o ID de um nome de marcador, use esta consulta:

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

Recuperar rótulos aplicados a um cliente

Ao receber a hierarquia de contas em uma conta de administrador, é possível recuperar a lista de rótulos aplicados a uma conta de cliente secundária solicitando o campo applied_labels do objeto CustomerClient. Esse campo recupera apenas os marcadores que pertencem ao cliente que faz a chamada de API.

Usar rótulos em relatórios

Use rótulos para melhorar a utilidade dos seus relatórios.

Relatórios de rótulos

O recurso de relatório Label retorna detalhes sobre os rótulos definidos em uma conta. Os detalhes incluem o nome, o ID, o nome do recurso, o status, a cor do plano de fundo e a descrição, além do recurso Cliente que representa o proprietário do marcador.

Relatórios com métricas

As visualizações de relatório Ad Group e Campaign contêm o campo labels. O serviço de relatórios retorna os nomes de recursos de rótulo no formato customers/{customer_id}/labels/{label_id}. Por exemplo, o nome de recurso customers/123456789/labels/012345 se refere ao rótulo com o ID 012345 na conta com o ID 123456789.

Relatórios sem métricas

Cada um dos recursos de relatório a seguir pode ser usado para encontrar relações entre recursos e rótulos:

• Rótulo do anúncio do grupo de anúncios
• Rótulo do critério do grupo de anúncios
• Rótulo do grupo de anúncios
• Rótulo da campanha
• Rótulo do cliente

É possível filtrar os resultados do relatório comparando o campo label.id usando qualquer operador de comparação numérica ou os operadores BETWEEN, IS NULL, IS NOT NULL, IN ou NOT IN.

Neste exemplo, você pode receber todas as campanhas com um ID de rótulo específico:

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