Guida rapida

Questa guida rapida ti aiuta a effettuare la tua prima chiamata API all'API Google Ads.

Concetti fondamentali

  • **Progetto Google Cloud:** un progetto Google Cloud è la base per creare, abilitare e utilizzare tutti i servizi Google, inclusa la gestione delle API e delle credenziali API OAuth 2.0. Puoi crearne uno dalla console Google Cloud.
  • Livello di accesso API: il livello di accesso API del tuo progetto Google Cloud controlla il numero di chiamate API che puoi effettuare al giorno e gli ambienti a cui puoi effettuare chiamate API. Il livello di accesso API del tuo progetto è elencato nella pagina Panoramica dell'API Google Ads del progetto.
  • Account amministratore Google Ads: un account amministratore Google Ads viene utilizzato per gestire altri account Google Ads, che potrebbero essere una raccolta di account cliente Google Ads o altri account amministratore Google Ads.
  • Account cliente Google Ads: l'account Google Ads utilizzato per pubblicare gli annunci che vuoi scegliere come target con le chiamate API.
  • ID cliente: il numero a 10 cifre che identifica un account cliente Google Ads. Se hai copiato questo ID dall'interfaccia utente di Google Ads, assicurati di rimuovere i trattini.
  • OAuth 2.0: OAuth 2.0 è un protocollo standard di settore per l'autorizzazione, utilizzato da tutte le API di Google. Per generare le credenziali OAuth 2.0 per effettuare chiamate API, devi disporre di un account di servizio e di una chiave.
  • Account di servizio: un tipo speciale di Account Google che appartiene alla tua applicazione anziché a un singolo utente. Viene utilizzato per autenticare la tua applicazione nell'API Google Ads. Per ottenere un account di servizio, devi disporre di un progetto Google Cloud.
  • Chiave dell'account di servizio: un file di credenziali dell'app JSON che contiene la chiave privata del tuo account di servizio. Viene utilizzato per generare le credenziali OAuth 2.0 per autenticare un account di servizio quando si effettua una chiamata API Google Ads. Per ottenere una chiave dell'account di servizio, devi disporre di un account di servizio.

Prerequisiti

Per effettuare una chiamata API Google Ads, devi completare i seguenti passaggi.

Configurare il progetto della console API di Google per l'accesso all'API Google Ads

Il progetto Google Cloud viene utilizzato per gestire le API di Google e le credenziali API OAuth 2.0. Puoi trovare i tuoi progetti Google Cloud esistenti o crearne uno visitando la console Google Cloud.

Per iniziare, abilita l'API Google Ads nel tuo progetto:

Abilitare l'API Google Ads

Poi, visita la pagina Panoramica dell'API Google Ads. La pagina mostra il livello di accesso API attuale. Se il livello di accesso API attuale è Test Livello di accesso all'account, espandi la sezione Richiedi il livello di accesso successivo. Segui le istruzioni per richiedere il livello di accesso Explorer.

Una volta completata la richiesta, Google la esaminerà automaticamente e, nella maggior parte dei casi, la aggiornerà al livello di accesso Explorer. Se non ti è stato concesso l'accesso Explorer, non preoccuparti. Questa guida fornirà le istruzioni appropriate per la configurazione dell'account cliente Google Ads.

Creare un account di servizio

Per effettuare chiamate API, devi disporre di un account di servizio e di una chiave dell'account di servizio. Se utilizzi già un'altra API di Google e hai creato un account di servizio e una chiave OAuth 2.0, puoi saltare questo passaggio e riutilizzare le credenziali esistenti.

Come creare un account di servizio e una chiave

  1. Nella console Google Cloud, vai a Menu > IAM e amministrazione > Account di servizio.

    Vai a Service account

  2. Seleziona il tuo account di servizio.
  3. Fai clic su Chiavi > Aggiungi chiave > Crea nuova chiave.
  4. Seleziona JSON, poi fai clic su Crea.

    Una nuova coppia di chiavi pubblica/privata viene generata e scaricata sul tuo computer come nuovo file. Salva il file JSON scaricato come credentials.json nella directory di lavoro. Questo file è l'unica copia di questa chiave.

  5. Fai clic su Chiudi.

Per iniziare, identifica l'account Google Ads su cui stai effettuando le chiamate API. Il tipo di account su cui puoi effettuare chiamate API dipende dal livello di accesso API del tuo progetto Google Cloud. Controlla la pagina Panoramica dell'API Google Ads per scoprire il tuo livello di accesso API.

Livelli di accesso Explorer, Basic e Standard

Puoi effettuare chiamate al tuo account di produzione Google Ads. Tuttavia, se necessario, puoi creare un account di test Google Ads seguendo le istruzioni riportate nella scheda Accesso all'account di test.

Livello di accesso all'account di test

Il tuo progetto Google Cloud non può essere utilizzato per effettuare chiamate API a un account di produzione Google Ads. Puoi effettuare chiamate API solo agli account di test Google Ads.

Come creare un account di test Google Ads

Le seguenti istruzioni creano un account amministratore di test Google Ads e un account inserzionista Google Ads di test Google Ads.

  1. Fai clic sul pulsante blu per creare un account amministratore di test Google Ads. Se ti viene richiesto, accedi con un Account Google non collegato al tuo Google Ads production manager account. Se non ne hai uno, utilizza il Crea account pulsante nella pagina per creare un nuovo Account Google.

    Creare un account amministratore di test Google Ads

  2. Nell'account amministratore di test Google Ads, crea un account cliente di test Google Ads: fai clic su Account > > Crea nuovo account e compila il modulo. Tutti gli account Google Ads che crei dall'account amministratore di test Google Ads sono automaticamente account di test Google Ads.
  3. (Facoltativo) Crea alcune campagne nell'account cliente di test Google Ads dalla pagina Google Ads.

Per effettuare una chiamata API a un cliente Google Ads, devi concedere l'accesso e le autorizzazioni appropriate al tuo account di servizio all'account cliente Google Ads. Per farlo, devi disporre dell'accesso amministrativo all'account cliente.

Come concedere l'accesso all'account di servizio al tuo account Google Ads account

  1. Per iniziare, accedi al tuo account Google Ads come amministratore.
  2. Vai ad Amministratore > Accesso e sicurezza.
  3. Fai clic sul pulsante nella scheda Utenti.
  4. Digita l'indirizzo email dell'account di servizio nella casella di input Email. Seleziona il livello di accesso all'account appropriato e fai clic sul pulsante Aggiungi account. Tieni presente che il livello di accesso Email non è supportato per account di servizio.
  5. L'accesso al service account è stato concesso.
  6. [Facoltativo] Per impostazione predefinita, non puoi concedere l'accesso amministrativo a un account di servizio. Se le chiamate API richiedono l'accesso amministrativo, puoi aggiornare l'accesso nel seguente modo.
    1. Fai clic sulla freccia menu a discesa accanto al livello di accesso dell'account di servizio nella colonna Livello di accesso.
    2. Seleziona Amministratore dall'elenco a discesa.

Scaricare strumenti e librerie client

Puoi scegliere di scaricare una libreria client o un client HTTP a seconda di come vuoi effettuare le chiamate API.

Utilizzare una libreria client

Scarica e installa una libreria client a tua scelta.

Utilizzare il client HTTP (REST)

curl

Scarica e installa curl, lo strumento a riga di comando per trasferire i dati tramite un URL.

Google Cloud CLI

Segui le istruzioni per installare gcloud CLI.

Le istruzioni per il resto di questa guida sono state verificate per funzionare con la seguente versione dello strumento gcloud e potrebbero non funzionare con le versioni precedenti a causa di differenze nel comportamento dell'applicazione o nelle opzioni della riga di comando.

:~$ gcloud version
Google Cloud SDK 492.0.0
alpha 2024.09.06
beta 2024.09.06
bq 2.1.8
bundled-python3-unix 3.11.9
core 2024.09.06
enterprise-certificate-proxy 0.3.2
gcloud-crc32c 1.0.0
gsutil 5.30

Eseguire una chiamata API

Seleziona il client che preferisci per le istruzioni su come effettuare una chiamata API:

Java

Gli artefatti della libreria client vengono pubblicati nel repository centrale Maven. Aggiungi la libreria client come dipendenza al tuo progetto nel seguente modo:

La dipendenza Maven è:

<dependency>
  <groupId>com.google.api-ads</groupId>
  <artifactId>google-ads</artifactId>
  <version>46.0.0</version>
</dependency>

La dipendenza Gradle è:

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

Ti consigliamo inoltre di utilizzare la distinta base dell'API Google Ads (BOM) per gestire le versioni delle dipendenze. Per le istruzioni, consulta la guida alla distinta base .

Crea un file ~/ads.properties con i seguenti contenuti:

api.googleads.serviceAccountSecretsPath=JSON_KEY_FILE_PATH
api.googleads.loginCustomerId=INSERT_LOGIN_CUSTOMER_ID_HERE

Crea un oggetto GoogleAdsClient nel seguente modo:

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

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account.

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

C#

I pacchetti della libreria client vengono pubblicati nel repository Nuget.org. Per iniziare, aggiungi un riferimento nuget al pacchetto Google.Ads.GoogleAds.

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

Crea un oggetto GoogleAdsConfig con le impostazioni pertinenti e utilizzalo per creare un oggetto GoogleAdsClient.

GoogleAdsConfig config = new GoogleAdsConfig()
{
    OAuth2Mode = OAuth2Flow.SERVICE_ACCOUNT,
    OAuth2SecretsJsonPath = "PATH_TO_CREDENTIALS_JSON",
    LoginCustomerId = ******
};
GoogleAdsClient client = new GoogleAdsClient(config);

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account. Questa guida non tratta i dettagli dei report.

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

PHP

I pacchetti della libreria client vengono pubblicati nel repository Packagist. Passa alla directory principale del tuo progetto ed esegui il seguente comando per installare la libreria e tutte le relative dipendenze nella directory vendor/ della directory principale del progetto.

composer require googleads/google-ads-php:33.6.0

Crea una copia del google_ads_php.ini file dal repository GitHub e modificalo per includere le tue credenziali.

[GOOGLE_ADS]
loginCustomerId = "INSERT_LOGIN_CUSTOMER_ID_HERE"

[OAUTH2]
jsonKeyFilePath = "INSERT_ABSOLUTE_PATH_TO_OAUTH2_JSON_KEY_FILE_HERE"
scopes = "https://www.googleapis.com/auth/adwords"

Crea un'istanza dell'oggetto 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();

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account.

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

Python

La libreria client viene distribuita su PyPI può essere installata utilizzando il pip comando nel seguente modo:

python -m pip install google-ads==31.2.0

Crea una copia del google-ads.yaml file dal repository GitHub e modificalo per includere le tue credenziali.

login_customer_id: INSERT_LOGIN_CUSTOMER_ID_HERE
json_key_file_path: JSON_KEY_FILE_PATH_HERE

Crea un'istanza GoogleAdsClient chiamando il GoogleAdsClient.load_from_storage metodo. Passa il percorso a google-ads.yaml come stringa al metodo quando lo chiami:

from google.ads.googleads.client import GoogleAdsClient
client = GoogleAdsClient.load_from_storage("path/to/google-ads.yaml")

Aggiungi un gestore al logger della libreria che indica dove stampare i log. Il seguente comando indica al logger della libreria di stampare sulla console (stdout).

import logging
import sys

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

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account.

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.'
            )

Ruby

Le gemme Ruby per la libreria client vengono pubblicate nel sito di hosting di gemme Rubygems. Il modo consigliato per installare è utilizzare bundler. Aggiungi una riga al tuo Gemfile:

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

Dopodiché, esegui:

bundle install

Crea una copia del google_ads_config.rb file dal repository GitHub e modificalo per includere le tue credenziali.

Google::Ads::GoogleAds::Config.new do |c|
  c.login_customer_id = 'INSERT_LOGIN_CUSTOMER_ID_HERE'
  c.keyfile = 'JSON_KEY_FILE_PATH'
end

Crea un'istanza GoogleAdsClient passando il percorso in cui conservi questo file.

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

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account.

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

Perl

La libreria viene distribuita su CPAN. Per iniziare, clona il repository google-ads-perl nella directory che preferisci.

git clone https://github.com/googleads/google-ads-perl.git

Passa alla directory google-ads-perl ed esegui il seguente comando al prompt dei comandi per installare tutte le dipendenze necessarie per utilizzare la libreria.

cd google-ads-perl
cpan install Module::Build
perl Build.PL
perl Build installdeps

Crea una copia del googleads.properties file dal repository GitHub e modificalo per includere le tue credenziali.

jsonKeyFilePath=JSON_KEY_FILE_PATH
loginCustomerId=INSERT_LOGIN_CUSTOMER_ID_HERE

Crea un'istanza Client passando il percorso in cui conservi questo file.

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

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

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account.

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::V25::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;
}

curl

Per iniziare, imposta l'account di servizio come credenziali attive in gcloud CLI.

gcloud auth login --cred-file=PATH_TO_CREDENTIALS_JSON

Poi, recupera un token di accesso OAuth 2.0 per l'API Google Ads.

gcloud auth \
  print-access-token \
  --scopes='https://www.googleapis.com/auth/adwords'

Poi, esegui un report sulle campagne utilizzando il metodo GoogleAdsService.SearchStream per recuperare le campagne nel tuo account.

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

I contenuti di query.json sono i seguenti:

{
  "query": "SELECT campaign.id, campaign.name, campaign.network_settings.target_content_network FROM campaign ORDER BY campaign.id"
}

Se riscontri errori durante la prima chiamata, consulta Gestire gli errori API per indicazioni sulla risoluzione dei problemi.

Indietro
Presentazione
Avanti
Gestisci gli errori