Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Démarrage rapide

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

Concepts clés

Projet Google Cloud : un projet Google Cloud constitue la base de la création, de l'activation et de 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.
Niveau d'accès à l'API : le niveau d'accès à l'API de votre projet Google Cloud 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. Le niveau d'accès à l'API de votre projet est indiqué sur la page Vue d'ensemble de l'API Google Ads de votre projet.
Compte administrateur Google Ads : un compte administrateur Google Ads permet de gérer d'autres comptes Google Ads, qui peuvent être un ensemble de comptes client Google Ads ou d'autres comptes administrateur Google Ads.
Compte client Google Ads : compte Google Ads utilisé pour diffuser les annonces que vous souhaitez cibler avec des appels d'API.
Numéro client : numéro à 10 chiffres qui identifie un compte client Google Ads. Si vous avez copié cet ID depuis l'interface utilisateur de Google Ads, veillez à supprimer les traits d'union.
OAuth 2.0 : OAuth 2.0 est un protocole d'autorisation standard du secteur, utilisé par toutes les API Google. 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.
Compte de service : type particulier de compte Google qui appartient à votre application plutôt qu'à un utilisateur individuel. Il permet d'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 permet de générer des identifiants OAuth 2.0 pour authentifier un compte de service lors d'un appel d'API Google Ads. Vous devez disposer 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 :

Configurer votre projet Cloud pour accéder à l'API Google Ads

Le projet Google Cloud permet de gérer les API Google et les identifiants de l'API OAuth 2.0. Vous pouvez trouver vos projets Google Cloud existants ou en créer un en accédant à la console Google Cloud.

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

Activer l'API Google Ads

Ensuite, accédez à la page de présentation de l'API Google Ads. La page affiche votre niveau d'accès actuel à l'API. Si votre niveau d'accès actuel à l'API est Test, développez la section Augmenter le niveau d'accès. Suivez les instructions pour demander le niveau d'accès Explorateur.

Une fois votre demande complétée, Google l'examinera automatiquement et la fera passer au niveau Explorer dans la plupart des cas. Si vous n'avez pas obtenu l'accès Explorer, ne vous inquiétez pas. Ce guide vous fournira les instructions appropriées lors de la configuration de votre compte client Google Ads.

Créer un compte de service

Vous devez disposer 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é

Dans la console Google Cloud, accédez à Menu > IAM et administration > Comptes de service.
Accéder à la page "Comptes de service"
Sélectionnez votre compte de service.
Cliquez sur Clés > Ajouter une clé > Créer une clé.
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 ordinateur sous la forme d'un nouveau fichier. Enregistrez le fichier JSON téléchargé sous le nom credentials.json dans votre répertoire de travail. Ce fichier est la seule copie de cette clé. N'intégrez pas credentials.json au contrôle des versions (par exemple, ajoutez-le à votre fichier .gitignore).
Cliquez sur Fermer.

Configurer votre compte client Google Ads

Commencez par identifier le compte Google Ads pour 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 projet Google Cloud. Consultez la page de présentation de l'API Google Ads pour connaître votre niveau d'accès à l'API.

Niveaux d'accès Explorer, Basic et Standard

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

Tester l'accès

Votre projet Google Cloud 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 sur des comptes de test Google Ads.

Créer un compte de test Google Ads

Les instructions suivantes permettent de créer un compte administrateur de test Google Ads et un compte d'annonceur de test Google Ads associé.

Cliquez sur le bouton bleu pour créer un compte administrateur de 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 avez pas, utilisez le bouton Créer un compte sur cette page pour créer un compte Google.

Créer un compte administrateur de test Google Ads
Dans votre compte administrateur de test Google Ads, créez un compte client de 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 de test Google Ads sont automatiquement des comptes de test Google Ads.
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 à votre compte de service l'accès et les autorisations appropriés au compte client Google Ads. Pour ce faire, vous devez disposer d'un accès administrateur au compte client.

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

Pour commencer, connectez-vous à votre compte Google Ads en tant qu'administrateur.
Accédez à Admin > Accès et sécurité.
Cliquez sur le bouton sous l'onglet Utilisateurs.
Saisissez l'adresse e-mail du compte de service dans le champ Adresse e-mail. Sélectionnez le niveau d'accès au compte approprié, puis cliquez sur le bouton Ajouter un compte. Notez que le niveau d'accès "E-mail" n'est pas compatible avec les comptes de service.
Le compte de service se voit accorder l'accès.
[Facultatif] Vous ne pouvez pas accorder d'accès administrateur à un compte de service lors de la configuration initiale. 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 Admin 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 les 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.

L'interface de ligne de commande Google Cloud

Suivez le guide d'installation de la Google Cloud CLI pour installer la gcloud CLI.

Les instructions du reste de ce guide ont été validées pour fonctionner avec la version suivante de l'outil gcloud. Elles peuvent ne pas fonctionner avec les versions précédentes en raison de différences de comportement de l'application ou d'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 Maven Central.

Pour gérer les versions des dépendances et éviter les conflits, consultez le guide de la nomenclature de l'API Google Ads.

Si vous n'utilisez pas la BOM, ajoutez la bibliothèque cliente directement à votre projet à l'aide de l'un des outils de compilation suivants :

Maven : ajoutez la dépendance suivante à votre fichier pom.xml :

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

Gradle : ajoutez la dépendance suivante à votre fichier build.gradle :

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

Créez un fichier ads.properties dans votre répertoire d'accueil (~/ads.properties sous Linux et macOS, ou %USERPROFILE%\ads.properties sous Windows) avec le contenu suivant :

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

Avant d'exécuter des requêtes API, créez une instance GoogleAdsClient. Par défaut, fromPropertiesFile() charge les identifiants à partir du fichier ads.properties situé dans votre répertoire d'accueil :

GoogleAdsClient googleAdsClient;
try {
  googleAdsClient = GoogleAdsClient.newBuilder().fromPropertiesFile().build();
} catch (IOException e) {
  System.err.printf("Failed to create GoogleAdsClient: %s%n", e);
  throw new RuntimeException("Initialization failed", e);
}

Ensuite, exécutez un rapport sur les campagnes à l'aide de GoogleAdsService.SearchStream pour diffuser efficacement de grands ensembles de résultats et 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());
      }
    }
  }
}GetCampaigns.java

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 de package NuGet au package Google.Ads.GoogleAds :

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

Pour effectuer des appels d'API, créez un objet GoogleAdsConfig à partir de vos paramètres de configuration (tels que appsettings.json, des variables d'environnement ou des paramètres personnalisés) et transmettez-le pour initialiser une instance GoogleAdsClient :

GoogleAdsConfig config = new GoogleAdsConfig()
{
    OAuth2Mode = OAuth2Flow.SERVICE_ACCOUNT,
    OAuth2SecretsJsonPath = "JSON_KEY_FILE_PATH",
    LoginCustomerId = "INSERT_LOGIN_CUSTOMER_ID_HERE"
};
GoogleAdsClient client = new GoogleAdsClient(config);

Ensuite, exécutez 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.V26.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;
    }
}GetCampaigns.cs

PHP

Les packages de la bibliothèque cliente sont publiés dans le dépôt Packagist. Assurez-vous de disposer d'une version compatible de PHP et de Composer, puis accédez au répertoire racine de votre projet et exécutez la commande suivante pour installer la bibliothèque et ses dépendances dans le répertoire vendor/ de votre projet :

composer require googleads/google-ads-php:35.3.0

Faites une copie du fichier google_ads_php.ini à partir du dépôt GitHub, enregistrez-la dans votre répertoire d'accueil ou dans le répertoire racine de votre projet, puis modifiez-la pour inclure vos identifiants :

[GOOGLE_ADS]
loginCustomerId = "INSERT_LOGIN_CUSTOMER_ID_HERE"

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

Créez une instance GoogleAdsClient à l'aide de votre fichier de configuration google_ads_php.ini :

use Google\Ads\GoogleAds\Lib\OAuth2TokenBuilder;
use Google\Ads\GoogleAds\Lib\V26\GoogleAdsClientBuilder;

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

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

Ensuite, exécutez 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
        );
    }
}GetCampaigns.php

Python

La bibliothèque cliente de l'API Google Ads pour Python est distribuée sur PyPI. Assurez-vous qu'une version compatible de Python est installée, puis installez la bibliothèque à l'aide de pip :

python -m pip install google-ads==35.0.0

Pour authentifier vos appels d'API, configurez un fichier google-ads.yaml :

Téléchargez une copie de l'exemple de fichier google-ads.yaml à partir du dépôt GitHub.
Enregistrez le fichier dans votre répertoire d'accueil (~/google-ads.yaml) ou dans un chemin d'accès personnalisé.
Ouvrez google-ads.yaml et mettez-le à jour pour inclure vos identifiants :
```
login_customer_id: INSERT_LOGIN_CUSTOMER_ID_HERE
json_key_file_path: JSON_KEY_FILE_PATH
```
Configurez la journalisation avant d'initialiser le client afin que la bibliothèque capture les avertissements d'initialisation ou de configuration. L'exemple suivant configure l'enregistreur de la bibliothèque pour qu'il génère des journaux INFO vers la sortie standard (stdout) :

import logging
import sys

logger = logging.getLogger("google.ads.googleads.client")
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler(sys.stdout))

Créez une instance GoogleAdsClient en appelant la méthode GoogleAdsClient.load_from_storage et en transmettant le chemin d'accès à votre fichier google-ads.yaml :

from google.ads.googleads.client import GoogleAdsClient

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

Si vous omettez l'argument de chemin d'accès, load_from_storage() recherche par défaut le fichier de configuration dans votre répertoire d'accueil (~/google-ads.yaml).

Ensuite, exécutez 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.'
            )get_campaigns.py

Ruby

Les gems Ruby de la bibliothèque cliente sont publiés sur RubyGems. Assurez-vous qu'une version compatible de Ruby est installée, puis utilisez Bundler pour installer la bibliothèque :

Ajoutez le gem au fichier Gemfile de votre application :
```
gem 'google-ads-googleads', '~> 46.1.0'
```
Installez le gem en exécutant la commande suivante :
```
bundle install
```

Pour configurer vos identifiants :

Copiez l'exemple de fichier google_ads_config.rb à partir du dépôt GitHub.
Enregistrez le fichier dans le répertoire racine de votre projet ou dans votre répertoire d'accueil (~).
Ouvrez google_ads_config.rb et remplacez les valeurs d'espace réservé par vos identifiants de l'API Google Ads :
```
Google::Ads::GoogleAds::Config.new do |c|
  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 à votre fichier de configuration (google_ads_config.rb) :

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

Ensuite, exécutez 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
endget_campaigns.rb

Perl

La bibliothèque cliente Perl est distribuée sur CPAN et nécessite Perl 5.28 ou une version ultérieure, ainsi que le gestionnaire de paquets cpan ou cpanm.

Clonez 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 les commandes suivantes pour installer les dépendances requises et compiler la bibliothèque :
```
cd google-ads-perl
cpan install Module::Build
perl Build.PL
perl Build installdeps
perl Build
perl Build install
```

Pour configurer vos identifiants :

Copiez l'exemple de fichier de configuration googleads.properties du dépôt GitHub dans votre répertoire d'accueil (~/googleads.properties) :
```
cp googleads.properties ~/googleads.properties
```
Modifiez ~/googleads.properties pour inclure vos identifiants :
```
jsonKeyFilePath=JSON_KEY_FILE_PATH
loginCustomerId=INSERT_LOGIN_CUSTOMER_ID_HERE
```
Créez une instance Client en transmettant le chemin d'accès à votre fichier googleads.properties configuré (par exemple, ~/googleads.properties) :

my $api_client = Google::Ads::GoogleAds::Client->new({
  properties_file => "/path/to/googleads.properties"
});

Ensuite, exécutez 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::V26::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;
}get_campaigns.pl

Lorsqu'il est exécuté, le script diffuse les lignes correspondantes, puis affiche l'ID et le nom de chaque campagne de votre compte.

curl

Commencez par définir le compte de service comme identifiant actif dans gcloud CLI.

gcloud auth login --cred-file=JSON_KEY_FILE_PATH

Ensuite, récupérez 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'

Créez un fichier nommé query.json contenant votre requête en langage de requête Google Ads (GAQL) :

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

Exécutez 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/v26/customers/CUSTOMER_ID/googleAds:searchStream \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "login-customer-id: LOGIN_CUSTOMER_ID" \
  --data-binary "@query.json"

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

Présentation

Gérer les erreurs

Démarrage rapide Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Concepts clés

Prérequis

Configurer votre projet Cloud pour accéder à l'API Google Ads

Créer un compte de service

Créer un compte de service et une clé

Configurer votre compte client Google Ads

Niveaux d'accès Explorer, Basic et Standard

Tester l'accès

Créer un compte de test Google Ads

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

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

Utiliser une bibliothèque cliente

Utiliser un client HTTP (REST)

Effectuer un appel d'API

Java

C#

PHP

Python

Ruby

Perl

curl

Démarrage rapide