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 pour lequel un utilisateur disposant l'accès au compte Google Ads peut autoriser votre application, dans une configuration unique, à effectuer des appels d'API hors connexion vers le compte sans aucune 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, OAuth L'authentification 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, émettez plutôt un jeton d'actualisation.

OAuth2L

  1. Générez le jeton d'actualisation en exécutant la commande Outil oauth2l:

    oauth2l fetch --credentials credentials.json --scope adwords \
    --output_format refresh_token
``` The `credentials.json` file is from a [previous
step](/google-ads/api/docs/get-started/oauth-cloud-project#id-secret).

  1. La commande oauth2l ouvre une fenêtre de connexion à un compte Google dans une nouvelle 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 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é).

  2. Après avoir vérifié les champs d'application, 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 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>
``` The `credentials.json` file is from a [previous
step](/google-ads/api/docs/get-started/oauth-cloud-project#id-secret).

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

    Veillez à vous connecter avec l'adresse e-mail associée à l'étape à laquelle vous 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é).

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

    Le navigateur accède à l'adresse https://cloud.google.com/sdk/auth_success. indiquant que l'authentification a réussi.

    Authorization code granted. Please 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 tableau de bord Maven Central un dépôt de clés. 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>33.0.0</version>
</dependency>

La dépendance Gradle est:

implementation 'com.google.api-ads:google-ads:33.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 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 sur le site Web Nuget.org un dépôt de clés. 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 création de rapports.

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

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 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 google-ads.yaml en tant que chaîne à la méthode lors de son appel:

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 couvre pas les détails 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 dans le gem Ruby site d'hébergement. 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 du dépôt GitHub et modifiez-le pour y 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 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 du dépôt GitHub et modifiez-le pour y 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 à l'emplacement où vous stockez 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. Ce guide ne couvre pas les détails 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::V17::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 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