Effectuer un appel d'API

Ce guide nécessite plusieurs paramètres préalables configurés lors des étapes précédentes. Si vous ne l'avez pas déjà fait, commencez par l'introduction.

Ce guide fait également appel à des jetons d'actualisation. Ce processus permet à un utilisateur disposant d'un accès suffisant au compte Google Ads d'autoriser votre application, dans une configuration unique, à effectuer des appels d'API hors connexion sur le compte sans qu'aucune autre intervention de l'utilisateur ne soit nécessaire. Vous pouvez utiliser des jetons d'actualisation pour créer 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 après une durée limitée. Pour renouveler automatiquement le jeton d'accès, vous devez émettre un jeton d'actualisation à la place.

  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 à un compte Google dans une nouvelle fenêtre de navigateur et vous guide tout au long de la procédure d'authentification OAuth 2.0.

    Assurez-vous de vous connecter avec l'adresse e-mail de 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 niveaux d'accès, accordez l'autorisation en cliquant sur le bouton Continuer.

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

    Authorization code granted. Please close this tab.

    La commande oauth2l génère l'extrait de code 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"
}

Effectuer un appel d'API

Sélectionnez le client de votre choix pour savoir comment 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>30.0.0</version>
</dependency>

La dépendance Gradle est la suivante:

implementation 'com.google.api-ads:google-ads:30.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);
}

Générez 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 décrit pas en détail 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 des bibliothèques clientes 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 et 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);

Générez 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 décrit pas en détail la création de rapports.

  public void Run(GoogleAdsClient client, long customerId)
{
    // Get the GoogleAdsService.
    GoogleAdsServiceClient googleAdsService = client.GetService(
        Services.V16.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 des bibliothèques clientes sont publiés dans le dépôt Packagist. Accédez au répertoire racine de votre projet, puis 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:22.0.0

Faites 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();

Générez 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 décrit pas en détail 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, distribuée sur PyPI, peut être installée à l'aide de la commande pip comme suit:

python -m pip install google-ads==21.3.0

Faites 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 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")

Générez 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 décrit pas en détail 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 gems Ruby de la bibliothèque cliente sont publiés sur le site d'hébergement de gems Ruby. La méthode d'installation recommandée consiste à utiliser bundler. Ajoutez une ligne à votre fichier Gemfile:

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

Exécutez ensuite la commande ci-dessous :

bundle install

Faites 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 où vous conservez ce fichier.

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

Générez 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 décrit pas en détail 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 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

Faites 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 où vous conservez ce fichier.

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

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

Générez 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 décrit pas en détail 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::V16::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

Générez 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 décrit pas en détail la création de rapports.

curl -i -X POST https://googleads.googleapis.com/v16/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