Libellés

Les libellés vous permettent de classer vos campagnes, groupes d'annonces, annonces et mots clés, et d'utiliser ces catégories pour simplifier votre workflow de différentes manières.

Ce guide décrit les étapes à suivre pour effectuer les opérations suivantes :

• Créer des libellés de manière programmatique à l'aide de LabelService.
• Attribuer des libellés à vos campagnes à l'aide de CampaignLabelService requêtes.
• Récupérer et filtrer les résultats de rapports par libellé à l'aide de GoogleAdsService requêtes.

Ce guide se concentre sur les campagnes, mais vous pouvez utiliser la même approche pour les groupes d'annonces, les annonces et les mots clés. Cette API fournit également CustomerLabelService, qui permet aux comptes administrateur d'attribuer des libellés aux comptes enfants.

Cas d'utilisation

Voici des scénarios courants d'utilisation des libellés incluant les suivants :

• Votre compte comporte des campagnes que vous n'activez qu'à certaines périodes de l'année, et vous souhaitez les inclure ou les exclure des rapports.
• Vous avez ajouté un nouvel ensemble de mots clés à votre groupe d'annonces et vous souhaitez comparer leurs statistiques à celles d'autres mots clés de votre groupe d'annonces.
• Les utilisateurs de votre compte Google Ads gèrent chacun un sous-ensemble de campagnes, et vous souhaitez identifier l'ensemble des campagnes de chaque utilisateur.
• Votre application doit marquer l'état de certains objets.

Créer des libellés

Créez des libellés à l'aide d'un Label objet dont le text_label champ est défini :

1. Créez une TextLabel instance contenant une couleur d'arrière-plan et une description.
2. Créez une instance Label et attribuez TextLabel à son champ text_label.
3. Encapsulez Label dans un LabelOperation (create) et envoyez-la à LabelService.MutateLabels.

Notez l'ID du libellé créé pour les requêtes ultérieures. L'ID est intégré dans le resource_name champ dans le MutateLabelResult renvoyé dans le MutateLabelsResponse.

Vous pouvez également utiliser une requête GoogleAdsService Search ou SearchStream pour récupérer les ID et les noms de ressources des libellés.

Attribuer des libellés

Vous pouvez attribuer des libellés à vos campagnes, clients, groupes d'annonces, critères ou annonces à l'aide de l'opération Mutate dans le service correspondant.

Par exemple, pour attribuer des libellés à une campagne, transmettez un ou plusieurs CampaignLabelOperation objets à CampaignLabelService.MutateCampaignLabels. Chaque CampaignLabelOperation inclut une CampaignLabel instance, qui nécessite des noms de ressources complets dans les champs suivants :

• label : nom de ressource d'un libellé (par exemple, customers/{customer_id}/labels/{label_id}).
• campaign : nom de ressource d'une campagne (par exemple, customers/{customer_id}/campaigns/{campaign_id}).

Créez une instance CampaignLabel pour chaque paire libellé-campagne. Encapsulez-la dans une CampaignLabelOperation avec l'opération create et envoyez-la à CampaignLabelService.MutateCampaignLabels.

Ajouter des libellés de campagne

Voici un exemple de code montrant comment ajouter un libellé de campagne à une liste de campagnes :

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

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

Remarque : Bien qu'aucun exemple de code REST direct ne soit fourni pour cette étape, vous pouvez y parvenir à l'aide d'une requête REST manuelle.

Consultez la documentation sur l'interface REST de l'API Google Ads et les pages de référence spécifiques à la méthode. Vous devrez créer la charge utile JSON en fonction des définitions proto.

Ressources clés :

• Utiliser REST
• Structure de l'interface REST
• Mappages de champs JSON
• Consultez la documentation de référence de l'API REST pour le service et la méthode spécifiques.

Attribuer des libellés à des clients

L'attribution de libellés à un client est une tâche courante pour les comptes administrateur, qui leur permet de classer leurs comptes clients. Cette opération est effectuée à l'aide de CustomerLabelService. Les libellés créés par un compte administrateur appartiennent à ce compte et ne sont visibles que lorsque l'authentification est effectuée en tant que compte administrateur propriétaire.

Chaque CustomerLabelOperation inclut une CustomerLabel instance. Lorsque vous créez une relation client-libellé, gardez à l'esprit les points suivants :

• label : ce champ est obligatoire et doit correspondre au nom de ressource d'un libellé appartenant au compte administrateur, tel que customers/{MANAGER_ID}/labels/{LABEL_ID}.
• customer : ce champ est en sortie seule et ne doit pas être défini dans la requête. Le client auquel le libellé est appliqué est déterminé par le customer_id dans le chemin d'accès MutateCustomerLabelsRequest.

Remarque : Une seule MutateCustomerLabelsRequest ne peut modifier les libellés que pour le compte client spécifié dans la requête. Pour appliquer un libellé à plusieurs comptes clients, vous devez effectuer des appels d'API distincts pour chaque compte.

Récupérer des objets à l'aide de leurs libellés

Une fois que vous avez attribué des libellés à vos campagnes, vous pouvez utiliser les champs de libellé pour récupérer des objets par ID.

Transmettez une requête GAQL appropriée à une GoogleAdsService Search ou SearchStream requête. Par exemple, la requête suivante renvoie l'ID, le nom et les libellés de chaque campagne associée à l'un des trois ID de libellé :

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

Vous ne pouvez filtrer que par ID de libellé, et non par nom de libellé. Pour obtenir l'ID de libellé à partir d'un nom de libellé, utilisez la requête suivante :

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

Récupérer les libellés appliqués à un client

Lorsque vous obtenez la hiérarchie des comptes sous un compte administrateur, vous pouvez récupérer la liste des libellés appliqués à un compte client enfant en demandant le champ applied_labels de l'objet CustomerClient. Ce champ ne récupère que les libellés appartenant au client qui effectue l'appel d'API.

Utiliser des libellés dans les rapports

Utilisez des libellés pour améliorer l'utilité de vos rapports.

Rapports sur les libellés

La ressource de rapport sur les libellés renvoie des informations sur les libellés définis dans un compte. Ces informations incluent le nom, l'ID, le nom de ressource, l'état, la couleur d'arrière-plan et la description, ainsi que la ressource Client représentant le propriétaire du libellé.

Rapports avec des métriques

Les vues de rapport sur les groupes d'annonces et les campagnes contiennent le champ labels. Le service de reporting renvoie les noms de ressources des libellés au format customers/{customer_id}/labels/{label_id}. Par exemple, le nom de ressource customers/123456789/labels/012345 fait référence au libellé dont l'ID est 012345 dans le compte dont l'ID est 123456789.

Rapports sans métriques

Chacune des ressources de rapport suivantes peut être utilisée pour trouver des relations entre les ressources et les libellés :

• Libellé d'annonce de groupe d'annonces
• Libellé de critère de groupe d'annonces
• Libellé de groupe d'annonces
• Libellé de campagne
• Libellé de client

Vous pouvez filtrer les résultats de ces rapports en comparant le champ label.id à l'aide d'un opérateur de comparaison numérique ou des opérateurs BETWEEN, IS NULL, IS NOT NULL, IN ou NOT IN.

Dans cet exemple, vous pouvez obtenir toutes les campagnes avec un ID de libellé spécifique :

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