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 Introduction si vous ne l’avez pas 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 des workflows hors connexion, tels que des jobs Cron ou pipelines de données, et les workflows interactifs comme les 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 en temps réel. Pour renouveler automatiquement le jeton d'accès, vous devez effectuer une actualisation jeton à la place.

  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

    Le fichier credentials.json provient d'une ancienne version étape.

  2. La commande oauth2l ouvre une fenêtre de connexion à un compte Google dans un nouveau navigateur. et vous guide tout au long des étapes d'authentification OAuth 2.0.

    Veillez à vous connecter à l'aide de 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 paramètres avancés, 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 Bouton Continue (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"
}

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 tableau de bord Maven Central un dépôt de clés. Ajouter 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);
}

Générez ensuite un rapport sur les performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas 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 sur le site Web Nuget.org un dépôt de clés. Commencez par ajouter 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éez 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 performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas détails de la 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 package Packagist un dépôt de clés. Changer en le 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/ de votre dans le répertoire racine de votre projet.

composer require googleads/google-ads-php:22.0.0

Créez une copie du fichier google_ads_php.ini du dépôt GitHub et modifiez-le pour y 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 performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas 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. peut être installé à l'aide de la commande pip ; comme suit:

python -m pip install google-ads==21.3.0

Créer une copie du google-ads.yaml du dépôt GitHub et modifiez-le pour y 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 performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas 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 gems Ruby de la bibliothèque cliente sont publiés dans le gem Ruby site d'hébergement. Méthode recommandée à installer utilise 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 à l'emplacement où vous conservez ce .

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

Générez ensuite un rapport sur les performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas 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 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
});

Générez ensuite un rapport sur les performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas 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::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 performances de la campagne à l'aide du GoogleAdsService.SearchStream pour récupérer les campagnes de votre compte. Ce guide n'aborde pas détails de la création de rapports.

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

Voici le contenu de query.json:

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