Libellés

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

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

  • Créer des étiquettes de manière automatisée à l'aide de LabelService
  • Attribuer des libellés à vos campagnes à l'aide de Requêtes CampaignLabelService.
  • Récupérez et filtrez les résultats de rapports par libellé à l'aide de Requêtes GoogleAdsService.

Ce guide est consacré aux campagnes, mais vous pouvez utiliser la même approche pour les campagnes les groupes, les annonces et les mots clés. Notez que l'API fournit également CustomerLabelService, qui permet pour attribuer des libellés aux comptes enfants.

Cas d'utilisation

Scénarios types d'utilisation étiquettes incluent les éléments suivants:

  • Votre compte inclut des campagnes que vous n'activez qu'à certaines périodes de l'année. et si vous souhaitez les inclure ou les exclure facilement des rapports.
  • Vous avez ajouté un nouvel ensemble de mots clés à votre groupe d'annonces et vous souhaitez comparer leurs statistiques à 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 un moyen d'identifier l'ensemble de campagnes pour chaque utilisateur.
  • Votre application doit marquer l'état de certains objets.

Créer des libellés

Créez des libellés avec l'objet TextLabel:

  1. Créez une instance TextLabel.
  2. Définissez une couleur d'arrière-plan pour cet élément TextLabel.
  3. Saisissez du texte pour cet TextLabel dans le champ de description.
  4. Encapsulez le TextLabel dans un LabelOperation et envoyez-le à LabelService.MutateLabels

Prenez note des nouveaux libellés ID pour les requêtes ultérieures. Les ID sont intégrés dans la partie Champ resource_name dans MutateLabelResults renvoyé dans le MutateLabelsResponse

Vous pouvez également utiliser une requête LabelService.GetLabel. ou un GoogleAdsService Search ou SearchStream pour récupérer les ID.

Attribuer des étiquettes

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

Par exemple, pour attribuer des libellés à une campagne, transmettez un ou plusieurs CampaignLabelOperation jusqu'à CampaignLabelService.MutateCampaignLabels Chaque CampaignLabelOperation inclut un Instance CampaignLabel, qui contient ces :

  • label: ID d'un libellé
  • campaign: ID d'une campagne

Créez une instance CampaignLabel pour chaque paire libellé/campagne. Encapsulez-le dans un CampaignLabelOperation avec l'opération create et l'envoyer à CampaignService.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.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

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::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

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

Après avoir attribué des libellés à vos campagnes, vous pouvez utiliser les libellés champs pour récupérer des objets par identifiant.

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

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

Notez que vous ne pouvez filtrer que par ID de libellé, et non par nom de libellé. Pour obtenir l'ID du libellé à partir d'un nom d'étiquette, vous pouvez utiliser cette requête:

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

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

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

Utiliser des libellés dans les rapports

Rapports sur les libellés

La ressource de rapport Étiquette renvoie des informations sur les étiquettes définies dans un compte. Les détails incluent le nom, l'ID, le nom de la ressource, l'état, la couleur d'arrière-plan et la description, ainsi que la ressource représentant le propriétaire de l'étiquette.

Rapports avec métriques

Rapports sur les groupes d'annonces et les campagnes les vues contiennent le champ labels. Le service de création de rapports renvoie le libellé noms de ressources au format customers/{customer_id}/labels/{label_id}. Pour exemple, le nom de ressource customers/123456789/labels/012345 fait référence libellé associé à l'ID 012345 dans le compte associé à l'ID 123456789.

Rapports sans métriques

Chacune des ressources suivantes peut être utilisée pour identifier les relations entre ressources et étiquettes:

Vous pouvez filtrer les résultats du rapport ci-dessus en comparant le champ label.id à l'aide de n'importe quel opérateur de comparaison numérique ou les valeurs BETWEEN, IS NULL, IS NOT NULL, IN ou NOT IN.

Par exemple, vous pouvez obtenir toutes les campagnes avec un ID de libellé spécifique comme suit:

SELECT
  campaign.id,
  campaign.name,
  label.id,
  label.name
FROM campaign_label
WHERE label.id = LABEL_ID
ORDER BY campaign.id
Précédent
Zéro métrique
Suivant
Flux