Effectuer un appel d'API

Remarque : L'étape actuelle de ce tutoriel dépend du type d'application que vous créez. Nous vous recommandons vivement d'utiliser un compte de service pour effectuer des appels d'API. Toutefois, l'option d'authentification de l'utilisateur est également proposée comme alternative. Le reste de ce tutoriel sera personnalisé en fonction de votre choix.

Comptes de service Authentification de l'utilisateur

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

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

La dépendance Gradle est la suivante :

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

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);
}

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.

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 = OAuth2Flow.SERVICE_ACCOUNT,
    OAuth2SecretsJsonPath = "PATH_TO_CREDENTIALS_JSON",
    LoginCustomerId = ******
};
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.V20.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:29.0.0

Copiez le fichier google_ads_php.ini 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]
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();

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

Copiez le fichier google-ads.yaml du dépôt GitHub et modifiez-le pour 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 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 ligne suivante indique au journaliseur de la bibliothèque d'afficher les informations sur la console (stdout).

import logging
import sys

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

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.

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 pour la bibliothèque cliente sont publiés sur le site d'hébergement de gems Rubygems. La méthode recommandée pour l'installation est d'utiliser Bundler. Ajoutez une ligne à votre fichier Gemfile :

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

Exécutez ensuite la commande ci-dessous :

bundle install

Copiez le fichier google_ads_config.rb du dépôt GitHub et modifiez-le pour 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 de ce fichier.

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. Ce guide ne couvre pas les détails des 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 commandes 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 fichier googleads.properties du dépôt GitHub et modifiez-le pour 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
});

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.

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::V20::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 définir le compte de service comme identifiants actifs dans gcloud CLI.

gcloud auth login --cred-file=PATH_TO_CREDENTIALS_JSON

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'

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.

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