Effectuer un appel d'API

Ce guide nécessite plusieurs paramètres préalables qui ont été configurés dans les étapes précédentes. Commencez par la section Introduction si vous ne l'avez pas déjà fait.

Ce guide utilise également des jetons d'actualisation, un workflow dans lequel un utilisateur disposant d'un accès suffisant au compte Google Ads peut autoriser votre application, lors d'une configuration unique, à effectuer des appels d'API hors connexion au compte sans autre intervention de l'utilisateur. Vous pouvez utiliser des jetons d'actualisation pour créer à la fois des workflows hors connexion, tels que des tâches Cron ou des pipelines de données, et des workflows interactifs, tels que des applications Web ou mobiles.

Récupérer un jeton d'actualisation

L'API Google Ads utilise OAuth 2.0 comme mécanisme d'autorisation. Par défaut, l'authentification OAuth 2.0 émet un jeton d'accès qui expire au bout d'un certain temps. Pour renouveler automatiquement le jeton d'accès, émettez plutôt un jeton d'actualisation.

oauth2l

  1. Générez le jeton d'actualisation en exécutant l'outil oauth2l:

    oauth2l fetch --credentials credentials.json --scope adwords \
    --output_format refresh_token

    Le fichier credentials.json provient d'une étape précédente.

  2. La commande oauth2l ouvre une fenêtre de connexion au compte Google dans une nouvelle fenêtre de navigateur et vous guide à travers les étapes d'authentification OAuth 2.0.

    Assurez-vous de vous connecter avec l'adresse e-mail indiquée à l'étape où vous avez identifié votre numéro client de connexion.

    Si votre application n'est pas validée, un écran d'avertissement peut s'afficher. Dans ce cas, vous pouvez cliquer sur le lien Afficher les options avancées, puis sur l'option Accéder à PROJECT_NAME (non validé).

  3. Après avoir vérifié les champs d'application, accordez l'autorisation en cliquant sur le bouton Continue (Continuer).

    Une invite s'affiche dans le navigateur avec le texte suivant:

    Authorization code granted. Close this tab.

    La commande oauth2l génère l'extrait JSON suivant:

    {
  "client_id": "******.apps.googleusercontent.com",
  "client_secret": "******",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "refresh_token": "******",
  "type": "authorized_user"
}

CLI gcloud

  1. Générez le jeton d'actualisation en exécutant l'outil gcloud CLI:

    gcloud auth application-default \
  login --scopes=https://www.googleapis.com/auth/adwords,https://www.googleapis.com/auth/cloud-platform \
  --client-id-file=<path_to_credentials.json>

    Le fichier credentials.json provient d'une étape précédente.

  2. La commande gcloud ouvre une fenêtre de connexion au compte Google dans une nouvelle fenêtre de navigateur et vous guide à travers les étapes d'authentification OAuth 2.0.

    Assurez-vous de vous connecter avec l'adresse e-mail indiquée à l'étape où vous avez identifié votre numéro client de connexion.

    Si votre application n'est pas validée, un écran d'avertissement peut s'afficher. Dans ce cas, vous pouvez cliquer sur le lien Afficher les options avancées, puis sur l'option Accéder à PROJECT_NAME (non validé).

  3. Après avoir vérifié les champs d'application, cliquez sur le bouton Continuer pour accorder l'autorisation.

    Le navigateur accède à https://cloud.google.com/sdk/auth_success, ce qui indique que l'authentification a réussi.

    Authorization code granted. Close this tab.

    La commande gcloud affiche un résultat semblable à celui-ci:

    Credentials saved to file: [/****/.config/gcloud/application_default_credentials.json]

    Ouvrez maintenant le fichier application_default_credentials.json. Son contenu doit ressembler à ceci:

    {
  "account": "",
  "client_id": "******.apps.googleusercontent.com",
  "client_secret": "******",
  "refresh_token": "******",
  "type": "authorized_user",
  "universe_domain": "googleapis.com"
}

Autres

Si vous préférez utiliser curl ou votre propre client HTTP, consultez le guide OAuth 2.0 pour les applications mobiles et de bureau pour obtenir un exemple.

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>34.0.0</version>
</dependency>

La dépendance Gradle est la suivante:

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

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

api.googleads.clientId=INSERT_CLIENT_ID_HERE
api.googleads.clientSecret=INSERT_CLIENT_SECRET_HERE
api.googleads.refreshToken=INSERT_REFRESH_TOKEN_HERE
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. Ce guide ne couvre pas les détails de la création de rapports.

    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 nuget au package Google.Ads.GoogleAds.

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

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

GoogleAdsConfig config = new GoogleAdsConfig()
{
    DeveloperToken = "******",
    OAuth2Mode = "APPLICATION",
    OAuth2ClientId = "******.apps.googleusercontent.com",
    OAuth2ClientSecret = "******",
    OAuth2RefreshToken = "******",
    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 de la création de rapports.

    public void Run(GoogleAdsClient client, long customerId)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsService = client.GetService(
        Services.V18.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. 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:25.0.0

Créez une copie du fichier google_ads_php.ini à partir du dépôt GitHub et modifiez-le pour inclure vos identifiants.

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

[OAUTH2]
clientId = "INSERT_OAUTH2_CLIENT_ID_HERE"
clientSecret = "INSERT_OAUTH2_CLIENT_SECRET_HERE"
refreshToken = "INSERT_OAUTH2_REFRESH_TOKEN_HERE"

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. Ce guide ne couvre pas les détails de la création de rapports.

    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 est distribuée sur PyPI et peut être installée à l'aide de la commande pip comme suit:

python -m pip install google-ads==21.3.0

Créez une copie du fichier google-ads.yaml à partir du dépôt GitHub et modifiez-le pour inclure vos identifiants.

client_id: INSERT_OAUTH2_CLIENT_ID_HERE
client_secret: INSERT_OAUTH2_CLIENT_SECRET_HERE
refresh_token: INSERT_REFRESH_TOKEN_HERE
developer_token: INSERT_DEVELOPER_TOKEN_HERE
login_customer_id: INSERT_LOGIN_CUSTOMER_ID_HERE

Créez une instance GoogleAdsClient en appelant la méthode GoogleAdsClient.load_from_storage. Transmettez le chemin d'accès à votre google-ads.yaml sous la forme d'une 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")

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 de la création de rapports.

def main(client, customer_id):
    ga_service = client.get_service("GoogleAdsService")

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

    # Issues a search request using streaming.
    stream = ga_service.search_stream(customer_id=customer_id, query=query)

    for batch in stream:
        for row in batch.results:
            print(
                f"Campaign with ID {row.campaign.id} and name "
                f'"{row.campaign.name}" was found.'
            )
get_campaigns.py

Ruby

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

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

Exécutez ensuite la commande ci-dessous :

bundle install

Créez une copie du fichier google_ads_config.rb à partir du dépôt GitHub et modifiez-le pour inclure vos identifiants.

Google::Ads::GoogleAds::Config.new do |c|
  c.client_id = 'INSERT_CLIENT_ID_HERE'
  c.client_secret = 'INSERT_CLIENT_SECRET_HERE'
  c.refresh_token = 'INSERT_REFRESH_TOKEN_HERE'
  c.developer_token = 'INSERT_DEVELOPER_TOKEN_HERE'
  c.login_customer_id = 'INSERT_LOGIN_CUSTOMER_ID_HERE'
end

Créez une instance GoogleAdsClient en transmettant le chemin d'accès au 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. Ce guide ne couvre pas les détails de la création de rapports.

    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
get_campaigns.rb

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

Créez une copie du fichier googleads.properties à partir du dépôt GitHub et modifiez-le pour inclure vos identifiants.

clientId=INSERT_OAUTH2_CLIENT_ID_HERE
clientSecret=INSERT_OAUTH2_CLIENT_SECRET_HERE
refreshToken=INSERT_OAUTH2_REFRESH_TOKEN_HERE
developerToken=INSERT_DEVELOPER_TOKEN_HERE
loginCustomerId=INSERT_LOGIN_CUSTOMER_ID_HERE

Créez une instance Client en transmettant le chemin d'accès au 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. Ce guide ne couvre pas les détails de la création de rapports.

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

REST

Commencez par utiliser un client HTTP pour récupérer un jeton d'accès OAuth 2.0. Ce guide utilise la commande curl.

curl \
  --data "grant_type=refresh_token" \
  --data "client_id=CLIENT_ID" \
  --data "client_secret=CLIENT_SECRET" \
  --data "refresh_token=REFRESH_TOKEN" \
  https://www.googleapis.com/oauth2/v3/token

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 de la création de rapports.

curl -i -X POST https://googleads.googleapis.com/v18/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"
}
Précédent
Télécharger les outils et les bibliothèques
Suivant
Erreurs courantes