Démarrage rapide

Ce guide de démarrage rapide vous aide à effectuer votre premier appel d'API à l'API Google Ads.

Concepts clés

  • Jeton de développeur : chaîne alphanumérique de 22 caractères qui identifie votre application auprès des serveurs de l'API Google Ads. Il est obligatoire pour effectuer des appels d'API.
  • Niveau d'accès à l'API : le niveau d'accès à l'API de votre jeton de développeur contrôle le nombre d'appels d'API que vous pouvez effectuer par jour et les environnements vers lesquels vous pouvez effectuer des appels d'API.
  • **Compte administrateur Google Ads** : compte Google Ads utilisé pour gérer d'autres comptes Google Ads. Un compte administrateur Google Ads peut être utilisé pour gérer des comptes client Google Ads ou d'autres comptes administrateur Google Ads. Vous avez besoin d'un compte administrateur Google Ads pour obtenir un jeton de développeur.
  • Compte client Google Ads : compte Google Ads vers lequel vous effectuez des appels d'API.
  • Numéro client : numéro à 10 chiffres qui identifie un compte client Google Ads. Si vous avez copié cet ID à partir de l'interface utilisateur Google Ads, veillez à supprimer les traits d'union.
  • OAuth 2.0: OAuth 2.0 : protocole d'autorisation standard du secteur utilisé par toutes les Google APIs. Vous avez besoin d'un compte de service et d'une clé pour générer des identifiants OAuth 2.0 afin d'effectuer des appels d'API.
  • Projet Google Cloud : base pour la création, l'activation et l'utilisation de tous les services Google, y compris la gestion des API et des identifiants d'API OAuth 2.0. Vous pouvez en créer un dans la console Google Cloud.
  • Compte de service : type spécial de compte Google qui appartient à votre application plutôt qu'à un utilisateur individuel. Il est utilisé pour authentifier votre application auprès de l'API Google Ads. Vous avez besoin d'un projet Google Cloud pour obtenir un compte de service.
  • Clé de compte de service : fichier d'identifiants d'application JSON contenant la clé privée de votre compte de service. Il est utilisé pour générer des identifiants OAuth 2.0 afin d'authentifier un compte de service lors d'un appel d'API Google Ads. Vous avez besoin d'un compte de service pour obtenir une clé de compte de service.

Prérequis

Pour effectuer un appel d'API Google Ads, procédez comme suit.

Obtenir votre jeton de développeur

Si vous vous êtes déjà inscrit pour obtenir un jeton de développeur, vous pouvez le trouver en accédant au Centre API lorsque vous êtes connecté à votre compte administrateur Google Ads.

Accéder au Centre API

Si vous ne possédez pas de jeton de développeur, vous pouvez vous inscrire pour en obtenir un dans le Centre API.

S'inscrire pour obtenir un jeton de développeur

  1. Accédez à Centre API dans votre navigateur Web. Connectez-vous à votre compte administrateur Google Ads si vous y êtes invité. Créez un compte administrateur Google Ads si vous n'en possédez pas.
  2. Remplissez le formulaire d'accès à l'API et acceptez les conditions d'utilisation.
    • Assurez-vous que vos informations sont correctes et que l'URL du site Web de votre entreprise fonctionne. Si le site Web n'est pas en ligne, il est possible que Google ne puisse pas traiter votre demande et la refuse.
    • Assurez-vous que l'adresse e-mail de contact pour l'API que vous fournissez mène à une boîte de réception surveillée régulièrement. L'équipe de conformité des API de Google peut contacter cette adresse e-mail lors du processus d'examen pour obtenir des clarifications. Si nous ne parvenons pas à vous joindre, il est possible que Google n'accepte pas votre demande.
    • Vous pouvez modifier votre adresse e-mail de contact pour l'API dans le Centre API. Maintenez ces informations à jour, même après le processus de demande, afin que Google puisse vous envoyer des annonces de service importantes.

Une fois le processus de demande terminé, le jeton de développeur s'affiche dans le Centre API avec l'état En attente d'approbation. Votre jeton de développeur dispose désormais du niveau d'accès Accès au compte test.

Configurer votre projet dans la console Google APIs

Le projet dans la console Google APIs est utilisé pour gérer les API Google et les identifiants d'API OAuth 2.0. Vous pouvez trouver vos projets existants dans la console Google APIs ou en créer un en accédant à la console Google APIs.

Ouvrir la console Google APIs

Commencez par activer l'API Google Ads dans votre projet :

Activer l'API Google Ads

Vous avez ensuite besoin d'un compte de service et d'une clé de compte de service pour effectuer des appels d'API. Si vous utilisez déjà une autre API Google et que vous avez créé un compte de service et une clé OAuth 2.0, vous pouvez ignorer cette étape et réutiliser les identifiants existants.

Créer un compte de service et une clé

  1. Dans la console Google Cloud, accédez à Menu > IAM et administration > Comptes de service.

    Accéder à la page "Comptes de service"

  2. Sélectionnez votre compte de service.
  3. Cliquez sur Clés > Ajouter une clé > Créer une clé.
  4. Sélectionnez JSON, puis cliquez sur Créer.

    La nouvelle paire de clés publique/privée est générée et téléchargée sur votre machine sous forme de fichier. Enregistrez le fichier JSON téléchargé sous le nom credentials.json dans votre répertoire de travail. Il s'agit de la seule copie de cette clé.

  5. Cliquez sur Fermer.

Commencez par identifier le compte Google Ads vers lequel vous effectuez des appels d'API. Le type de compte vers lequel vous pouvez effectuer des appels d'API dépend du niveau d'accès à l'API de votre jeton de développeur. Consultez le Centre API pour connaître votre niveau d'accès à l'API.

Niveaux d'accès Explorateur, Basique et Standard

Vous pouvez effectuer des appels vers votre compte de production Google Ads. Toutefois, vous pouvez créer un compte test Google Ads en suivant les instructions de l'onglet Accès au compte test si nécessaire.

Niveau d'accès Accès au compte test

Votre jeton de développeur ne peut pas être utilisé pour effectuer des appels d'API vers un compte de production Google Ads. Vous ne pouvez effectuer des appels d'API que vers des comptes test Google Ads.

Créer un compte test Google Ads

Les instructions suivantes permettent de créer un compte administrateur test Google Ads et un compte annonceur test Google Ads en dessous.

  1. Cliquez sur le bouton bleu pour créer un compte administrateur test Google Ads. Si vous y êtes invité, connectez-vous avec un compte Google qui n'est pas associé à votre compte administrateur de production Google Ads. Si vous n'en possédez pas, utilisez le Créer un compte bouton sur cette page pour créer un nouveau compte Google.

    Créer un compte administrateur test Google Ads

  2. Dans votre compte administrateur test Google Ads, créez un compte client test Google Ads : cliquez sur Comptes > > Créer un compte , puis remplissez le formulaire. Tous les comptes Google Ads que vous créez à partir de votre compte administrateur test Google Ads sont automatiquement des comptes test Google Ads.
  3. Vous pouvez également créer quelques campagnes dans le compte client test Google Ads à partir de la page Google Ads.

Pour effectuer un appel d'API vers un client Google Ads, vous devez accorder l'accès et les autorisations appropriées à votre compte de service pour le compte client Google Ads. Pour ce faire, vous devez disposer d'un accès administrateur au compte client.

Accorder l'accès au compte de service à votre compte Google Ads

  1. Commencez par vous connecter à votre compte Google Ads en tant qu'administrateur.
  2. Accédez à Admin > Accès et sécurité.
  3. Cliquez sur le bouton dans l'onglet Utilisateurs.
  4. Saisissez l'adresse e-mail du compte de service dans le champ de saisie E-mail. Sélectionnez le niveau d'accès au compte approprié, puis cliquez sur le Ajouter un compte bouton. Notez que le niveau d'accès "E-mail" n'est pas compatible avec les comptes de service.
  5. L'accès est accordé au compte de service.
  6. [Facultatif] Par défaut, vous ne pouvez pas accorder d'accès administrateur à un compte de service. Si vos appels d'API nécessitent un accès administrateur, vous pouvez mettre à niveau l'accès comme suit.
    1. Cliquez sur la flèche du menu déroulant à côté du niveau d'accès du compte de service dans la colonne Niveau d'accès.
    2. Sélectionnez Administrateur dans la liste déroulante.

Télécharger des outils et des bibliothèques clientes

Vous pouvez choisir de télécharger une bibliothèque cliente ou un client HTTP, selon la façon dont vous souhaitez effectuer des appels d'API.

Utiliser une bibliothèque cliente

Téléchargez et installez la bibliothèque cliente de votre choix.

Utiliser un client HTTP (REST)

curl

Téléchargez et installez curl, l'outil de ligne de commande permettant de transférer des données via une URL.

CLI Google Cloud

Suivez les instructions pour installer la CLI gcloud.

Les instructions du reste de ce guide ont été testées et fonctionnent avec la version suivante de l'outil gcloud. Elles peuvent ne pas fonctionner avec les versions précédentes en raison de différences dans le comportement de l'application ou les options de ligne de commande.

:~$ gcloud version
Google Cloud SDK 492.0.0
alpha 2024.09.06
beta 2024.09.06
bq 2.1.8
bundled-python3-unix 3.11.9
core 2024.09.06
enterprise-certificate-proxy 0.3.2
gcloud-crc32c 1.0.0
gsutil 5.30

Effectuer un appel d'API

Sélectionnez le client de votre choix pour obtenir des instructions sur la façon d'effectuer un appel d'API :

Java

Les artefacts de la bibliothèque cliente sont publiés dans le dépôt central Maven. Ajoutez la bibliothèque cliente en tant que dépendance à votre projet comme suit :

La dépendance Maven est la suivante :

<dependency>
  <groupId>com.google.api-ads</groupId>
  <artifactId>google-ads</artifactId>
  <version>43.1.0</version>
</dependency>

La dépendance Gradle est la suivante :

implementation 'com.google.api-ads:google-ads:43.1.0'

Nous vous recommandons également d'utiliser la nomenclature de l'API Google Ads (BOM) pour gérer les versions des dépendances. Pour obtenir des instructions, consultez le guide de la nomenclature.

Créez un fichier ~/ads.properties avec le contenu suivant :

api.googleads.serviceAccountSecretsPath=JSON_KEY_FILE_PATH
api.googleads.developerToken=INSERT_DEVELOPER_TOKEN_HERE
api.googleads.loginCustomerId=INSERT_LOGIN_CUSTOMER_ID_HERE

Créez un objet GoogleAdsClient comme suit :

GoogleAdsClient googleAdsClient = null;
try {
  googleAdsClient = GoogleAdsClient.newBuilder().fromPropertiesFile().build();
} catch (FileNotFoundException fnfe) {
  System.err.printf(
      "Failed to load GoogleAdsClient configuration from file. Exception: %s%n",
      fnfe);
  System.exit(1);
} catch (IOException ioe) {
  System.err.printf("Failed to create GoogleAdsClient. Exception: %s%n", ioe);
  System.exit(1);
}

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte.

private void runExample(GoogleAdsClient googleAdsClient, long customerId) {
  try (GoogleAdsServiceClient googleAdsServiceClient =
      googleAdsClient.getLatestVersion().createGoogleAdsServiceClient()) {
    String query = "SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id";
    // Constructs the SearchGoogleAdsStreamRequest.
    SearchGoogleAdsStreamRequest request =
        SearchGoogleAdsStreamRequest.newBuilder()
            .setCustomerId(Long.toString(customerId))
            .setQuery(query)
            .build();

    // Creates and issues a search Google Ads stream request that will retrieve all campaigns.
    ServerStream<SearchGoogleAdsStreamResponse> stream =
        googleAdsServiceClient.searchStreamCallable().call(request);

    // Iterates through and prints all of the results in the stream response.
    for (SearchGoogleAdsStreamResponse response : stream) {
      for (GoogleAdsRow googleAdsRow : response.getResultsList()) {
        System.out.printf(
            "Campaign with ID %d and name '%s' was found.%n",
            googleAdsRow.getCampaign().getId(), googleAdsRow.getCampaign().getName());
      }
    }
  }
}

C#

Les packages de la bibliothèque cliente sont publiés dans le dépôt Nuget.org. Commencez par ajouter une référence NuGet au package Google.Ads.GoogleAds.

dotnet add package Google.Ads.GoogleAds --version 26.0.0

Créez un objet GoogleAdsConfig avec les paramètres pertinents, puis utilisez-le pour créer un objet GoogleAdsClient.

GoogleAdsConfig config = new GoogleAdsConfig()
{
    DeveloperToken = "******",
    OAuth2Mode = OAuth2Flow.SERVICE_ACCOUNT,
    OAuth2SecretsJsonPath = "PATH_TO_CREDENTIALS_JSON",
    LoginCustomerId = ******
};
GoogleAdsClient client = new GoogleAdsClient(config);

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide ne couvre pas les détails des rapports.

public void Run(GoogleAdsClient client, long customerId)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsService = client.GetService(
        Services.V24.GoogleAdsService);

    // Create a query that will retrieve all campaigns.
    string query = @"SELECT
                    campaign.id,
                    campaign.name,
                    campaign.network_settings.target_content_network
                FROM campaign
                ORDER BY campaign.id";

    try
    {
        // Issue a search request.
        googleAdsService.SearchStream(customerId.ToString(), query,
            delegate (SearchGoogleAdsStreamResponse resp)
            {
                foreach (GoogleAdsRow googleAdsRow in resp.Results)
                {
                    Console.WriteLine("Campaign with ID {0} and name '{1}' was found.",
                        googleAdsRow.Campaign.Id, googleAdsRow.Campaign.Name);
                }
            }
        );
    }
    catch (GoogleAdsException e)
    {
        Console.WriteLine("Failure:");
        Console.WriteLine($"Message: {e.Message}");
        Console.WriteLine($"Failure: {e.Failure}");
        Console.WriteLine($"Request ID: {e.RequestId}");
        throw;
    }
}

PHP

Les packages de la bibliothèque cliente sont publiés dans le dépôt Packagist. Accédez au répertoire racine de votre projet et exécutez la commande suivante pour installer la bibliothèque et toutes ses dépendances dans le répertoire vendor/ du répertoire racine de votre projet.

composer require googleads/google-ads-php:33.4.0

Copiez le google_ads_php.ini fichier à partir du dépôt GitHub et modifiez-le pour y inclure vos identifiants.

[GOOGLE_ADS]
developerToken = "INSERT_DEVELOPER_TOKEN_HERE"
loginCustomerId = "INSERT_LOGIN_CUSTOMER_ID_HERE"

[OAUTH2]
jsonKeyFilePath = "INSERT_ABSOLUTE_PATH_TO_OAUTH2_JSON_KEY_FILE_HERE"
scopes = "https://www.googleapis.com/auth/adwords"

Créez une instance de l'objet GoogleAdsClient.

$oAuth2Credential = (new OAuth2TokenBuilder())
    ->fromFile('/path/to/google_ads_php.ini')
    ->build();

$googleAdsClient = (new GoogleAdsClientBuilder())
    ->fromFile('/path/to/google_ads_php.ini')
    ->withOAuth2Credential($oAuth2Credential)
    ->build();

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte.

public static function runExample(GoogleAdsClient $googleAdsClient, int $customerId)
{
    $googleAdsServiceClient = $googleAdsClient->getGoogleAdsServiceClient();
    // Creates a query that retrieves all campaigns.
    $query = 'SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id';
    // Issues a search stream request.
    /** @var GoogleAdsServerStreamDecorator $stream */
    $stream = $googleAdsServiceClient->searchStream(
        SearchGoogleAdsStreamRequest::build($customerId, $query)
    );

    // Iterates over all rows in all messages and prints the requested field values for
    // the campaign in each row.
    foreach ($stream->iterateAllElements() as $googleAdsRow) {
        /** @var GoogleAdsRow $googleAdsRow */
        printf(
            "Campaign with ID %d and name '%s' was found.%s",
            $googleAdsRow->getCampaign()->getId(),
            $googleAdsRow->getCampaign()->getName(),
            PHP_EOL
        );
    }
}

Python

La bibliothèque cliente est distribuée sur PyPI peut être installée à l'aide de la pip commande comme suit :

python -m pip install google-ads==31.0.0

Copiez le fichier google-ads.yaml à partir du dépôt GitHub et modifiez-le pour y inclure vos identifiants.

developer_token: INSERT_DEVELOPER_TOKEN_HERE
login_customer_id: INSERT_LOGIN_CUSTOMER_ID_HERE
json_key_file_path: JSON_KEY_FILE_PATH_HERE

Créez une instance GoogleAdsClient en appelant la méthode GoogleAdsClient.load_from_storage. Transmettez le chemin d'accès à votre fichier google-ads.yaml sous forme de chaîne à la méthode lorsque vous l'appelez :

from google.ads.googleads.client import GoogleAdsClient
client = GoogleAdsClient.load_from_storage("path/to/google-ads.yaml")

Ajoutez un gestionnaire au journaliseur de la bibliothèque pour lui indiquer où imprimer les journaux. La commande suivante indique au journaliseur de la bibliothèque d'imprimer dans la console (stdout).

import logging
import sys

logger = logging.getLogger('google.ads.googleads.client')
logger.addHandler(logging.StreamHandler(sys.stdout))

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte.

def main(client: GoogleAdsClient, customer_id: str) -> None:
    ga_service: GoogleAdsServiceClient = client.get_service("GoogleAdsService")

    query: str = """
        SELECT
          campaign.id,
          campaign.name
        FROM campaign
        ORDER BY campaign.id"""

    # Issues a search request using streaming.
    stream: Iterator[SearchGoogleAdsStreamResponse] = ga_service.search_stream(
        customer_id=customer_id, query=query
    )

    for batch in stream:
        rows: List[GoogleAdsRow] = batch.results
        for row in rows:
            print(
                f"Campaign with ID {row.campaign.id} and name "
                f'"{row.campaign.name}" was found.'
            )

Ruby

Les gems Ruby pour la bibliothèque cliente sont publiées sur le site d'hébergement de gems Rubygems. La méthode d'installation recommandée consiste à utiliser Bundler. Ajoutez une ligne à votre fichier Gemfile :

gem 'google-ads-googleads', '~> 41.0.0'

Exécutez ensuite la commande ci-dessous :

bundle install

Copiez le google_ads_config.rb fichier à partir du dépôt GitHub et modifiez-le pour y inclure vos identifiants.

Google::Ads::GoogleAds::Config.new do |c|
  c.developer_token = 'INSERT_DEVELOPER_TOKEN_HERE'
  c.login_customer_id = 'INSERT_LOGIN_CUSTOMER_ID_HERE'
  c.keyfile = 'JSON_KEY_FILE_PATH'
end

Créez une instance GoogleAdsClient en transmettant le chemin d'accès à l'emplacement où vous conservez ce fichier.

client = Google::Ads::GoogleAds::GoogleAdsClient.new('path/to/google_ads_config.rb')

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte.

def get_campaigns(customer_id)
  # GoogleAdsClient will read a config file from
  # ENV['HOME']/google_ads_config.rb when called without parameters
  client = Google::Ads::GoogleAds::GoogleAdsClient.new

  responses = client.service.google_ads.search_stream(
    customer_id: customer_id,
    query: 'SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id',
  )

  responses.each do |response|
    response.results.each do |row|
      puts "Campaign with ID #{row.campaign.id} and name '#{row.campaign.name}' was found."
    end
  end
end

Perl

La bibliothèque est distribuée sur CPAN. Commencez par cloner le dépôt google-ads-perl dans le répertoire de votre choix.

git clone https://github.com/googleads/google-ads-perl.git

Accédez au répertoire google-ads-perl et exécutez la commande suivante dans l'invite de commande pour installer toutes les dépendances nécessaires à l'utilisation de la bibliothèque.

cd google-ads-perl
cpan install Module::Build
perl Build.PL
perl Build installdeps

Copiez le googleads.properties fichier à partir du dépôt GitHub et modifiez-le pour y inclure vos identifiants.

jsonKeyFilePath=JSON_KEY_FILE_PATH
developerToken=INSERT_DEVELOPER_TOKEN_HERE
loginCustomerId=INSERT_LOGIN_CUSTOMER_ID_HERE

Créez une instance Client en transmettant le chemin d'accès à l'emplacement où vous conservez ce fichier.

my $properties_file = "/path/to/googleads.properties";

my $api_client = Google::Ads::GoogleAds::Client->new({
  properties_file => $properties_file
});

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte.

sub get_campaigns {
  my ($api_client, $customer_id) = @_;

  # Create a search Google Ads stream request that will retrieve all campaigns.
  my $search_stream_request =
    Google::Ads::GoogleAds::V24::Services::GoogleAdsService::SearchGoogleAdsStreamRequest
    ->new({
      customerId => $customer_id,
      query      =>
        "SELECT campaign.id, campaign.name FROM campaign ORDER BY campaign.id"
    });

  # Get the GoogleAdsService.
  my $google_ads_service = $api_client->GoogleAdsService();

  my $search_stream_handler =
    Google::Ads::GoogleAds::Utils::SearchStreamHandler->new({
      service => $google_ads_service,
      request => $search_stream_request
    });

  # Issue a search request and process the stream response to print the requested
  # field values for the campaign in each row.
  $search_stream_handler->process_contents(
    sub {
      my $google_ads_row = shift;
      printf "Campaign with ID %d and name '%s' was found.\n",
        $google_ads_row->{campaign}{id}, $google_ads_row->{campaign}{name};
    });

  return 1;
}

curl

Commencez par définir le compte de service comme identifiants actifs dans la CLI gcloud.

gcloud auth login --cred-file=PATH_TO_CREDENTIALS_JSON

Récupérez ensuite un jeton d'accès OAuth 2.0 pour l'API Google Ads.

gcloud auth \
  print-access-token \
  --scopes='https://www.googleapis.com/auth/adwords'

Exécutez ensuite un rapport sur les campagnes à l'aide de la méthode GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte.

curl -i -X POST https://googleads.googleapis.com/v24/customers/CUSTOMER_ID/googleAds:searchStream \
   -H "Content-Type: application/json" \
   -H "Authorization: Bearer ACCESS_TOKEN" \
   -H "developer-token: DEVELOPER_TOKEN" \
   -H "login-customer-id: LOGIN_CUSTOMER_ID" \
   --data-binary "@query.json"

Le contenu de query.json est le suivant :

{
  "query": "SELECT campaign.id, campaign.name, campaign.network_settings.target_content_network FROM campaign ORDER BY campaign.id"
}

Si vous rencontrez des erreurs lors de votre premier appel, consultez la section Gérer les erreurs d'API pour obtenir des conseils sur le dépannage.

Précédent
Présentation
Suivant
Gérer les erreurs