Automatiser ses rapports Google Ads avec l'API : extraction, BigQuery et planification

Un rapport Google Ads automatisé tient en quatre étapes : une requête GAQL envoyée avec search_stream, un stockage dans BigQuery, le calcul des indicateurs avec pandas, puis un tableau de bord alimenté chaque jour par Cloud Scheduler. Avant d'écrire une ligne de code, vérifiez qu'un outil déjà fourni ne suffit pas : Data Studio (le nom repris par Google pour Looker Studio¹⁰) a un connecteur Google Ads natif⁹, et le service de transfert de BigQuery copie chaque jour vos données Google Ads dans vos tables⁸. L'API se justifie quand vous avez besoin de règles de calcul propres à votre activité ou d'un traitement particulier des comptes. Pour choisir entre les deux voies, voir les différences entre Google Ads Scripts et API.

Faut-il coder ses rapports ?

Quelles données sont à jour, et quand ?

Ce point conditionne votre calendrier de rapports¹ :

• clics, impressions, coût et conversions au dernier clic : mis à jour toutes les heures (objectif de fraîcheur d'une heure) ;
• conversions attribuées avec un autre modèle que le dernier clic, lieux et termes de recherche : disponibles le lendemain, à un horaire qui dépend du fuseau du compte ;
• parts d'impressions et informations sur les enchères : disponibles avec un décalage de plusieurs jours (à partir du mercredi après-midi pour les données du dimanche, à San Francisco) ;
• pour les conversions, la fraîcheur dépend du modèle d'attribution et du type de conversion.

Ne stockez donc pas seulement « hier » : relisez les derniers jours à chaque exécution. C'est aussi ce que fait le service de transfert BigQuery avec sa fenêtre de 7 jours⁸. Deux autres limites : depuis le 1er juin 2026, la segmentation granulaire (quotidienne, horaire, hebdomadaire) est limitée à 37 mois d'historique ; une requête plus ancienne renvoie DateRangeError.REQUESTED_DATE_GRANULARITY_NOT_SUPPORTED⁷. Et LAST_30_DAYS exclut aujourd'hui.

Comment accéder aux comptes sans intervention humaine ?

Pour un programme planifié, Google recommande un compte de service : une clé JSON que seule votre application détient, à la place d'un utilisateur qui autorise l'accès à la main⁶. Ajoutez l'e-mail du compte de service comme utilisateur dans Google Ads, avec le niveau d'accès nécessaire. Une même adresse e-mail ne peut être associée qu'à 20 comptes Google Ads : au-delà, ajoutez le compte de service à un compte administrateur qui regroupe vos comptes⁶. Stockez la clé dans un gestionnaire de secrets, jamais dans le dépôt de code.

Côté quotas : une requête Search ou SearchStream compte pour une opération, quel que soit le nombre de lignes². Récupérer les campagnes de 100 comptes une fois par jour consomme donc 100 opérations, à comparer aux 2 880 opérations quotidiennes de l'accès Explorer sur comptes réels³. Détails dans tarifs, quotas et limites de la Google Ads API, et pour l'accès dans accès à l'API avec OAuth2 et Google Cloud.

Étape 1 : extraire les données d'un compte

QUERY = """
    SELECT
      segments.date,
      customer.id,
      customer.currency_code,
      campaign.id,
      campaign.name,
      metrics.impressions,
      metrics.clicks,
      metrics.cost_micros,
      metrics.conversions,
      metrics.conversions_value
    FROM campaign
    WHERE segments.date BETWEEN '{start}' AND '{end}'
      AND campaign.status != 'REMOVED'
"""

def fetch_campaign_rows(client, customer_id, start, end):
    ga_service = client.get_service("GoogleAdsService")
    query = QUERY.format(start=start, end=end)
    rows = []
    for batch in ga_service.search_stream(customer_id=customer_id, query=query):
        for row in batch.results:
            rows.append({
                "date": row.segments.date,
                "account_id": str(row.customer.id),
                "currency": row.customer.currency_code,
                "campaign_id": row.campaign.id,
                "campaign": row.campaign.name,
                "impressions": row.metrics.impressions,
                "clicks": row.metrics.clicks,
                "cost": row.metrics.cost_micros / 1_000_000,
                "conversions": row.metrics.conversions,
                "conversions_value": row.metrics.conversions_value,
            })
    return rows

Le champ segments.date donne une ligne par campagne et par jour. Le coût est exprimé en micros, dans la devise du compte : gardez la colonne de devise si vos comptes n'ont pas tous la même. search_stream convient bien aux rapports de plusieurs pages². Le code d'extraction et de chargement de cet article a été exécuté avec google-ads 33.0.0 sur des réponses simulées, sans compte réel ; le tutoriel Python pour la Google Ads API détaille l'installation et la configuration.

Étape 2 : traiter plusieurs comptes clients

La méthode list_accessible_customers ne convient pas ici : elle ne renvoie que les comptes auxquels votre utilisateur a un accès direct, pas toute la hiérarchie⁵. Interrogez plutôt customer_client depuis le compte administrateur : la ressource contient tous les clients directs et indirects, ainsi que le compte administrateur lui-même⁴, d'où le filtre sur manager = FALSE.

def list_client_accounts(client, manager_id):
    query = """
        SELECT customer_client.id
        FROM customer_client
        WHERE customer_client.manager = FALSE
          AND customer_client.status = 'ENABLED'
    """
    ga_service = client.get_service("GoogleAdsService")
    response = ga_service.search(customer_id=manager_id, query=query)
    return [str(row.customer_client.id) for row in response]

Définissez login_customer_id (identifiant du compte administrateur) dans la configuration. Encadrez chaque compte d'un try/except GoogleAdsException pour qu'une erreur sur un compte n'arrête pas les autres.

Étape 3 : calculer les indicateurs

def add_kpis(df):
    df["ctr"] = df["clicks"] / df["impressions"].where(df["impressions"] > 0)
    df["cpc"] = df["cost"] / df["clicks"].where(df["clicks"] > 0)
    df["cpa"] = df["cost"] / df["conversions"].where(df["conversions"] > 0)
    df["roas"] = df["conversions_value"] / df["cost"].where(df["cost"] > 0)
    return df

Le CTR est le taux de clic, le CPC le coût par clic, le CPA le coût par conversion, le ROAS la valeur de conversion divisée par le coût. Le ROAS n'a de sens que si vos conversions ont une valeur configurée dans Google Ads. Additionnez des coûts uniquement entre comptes de même devise.

Étape 4 : stocker dans BigQuery sans doublons

from google.cloud import bigquery

def replace_period(df, table_id, start, end):
    bq = bigquery.Client()
    bq.create_table(bigquery.Table(table_id, schema=SCHEMA), exists_ok=True)
    bq.query(
        f"DELETE FROM `{table_id}` WHERE date BETWEEN @start AND @end",
        job_config=bigquery.QueryJobConfig(query_parameters=[
            bigquery.ScalarQueryParameter("start", "DATE", start),
            bigquery.ScalarQueryParameter("end", "DATE", end),
        ]),
    ).result()
    records = df[[field.name for field in SCHEMA]].to_dict("records")
    bq.load_table_from_json(
        records, table_id,
        job_config=bigquery.LoadJobConfig(
            schema=SCHEMA, write_disposition=bigquery.WriteDisposition.WRITE_APPEND
        ),
    ).result()

SCHEMA est la liste des colonnes de l'étape 1 (bigquery.SchemaField("date", "DATE"), ("cost", "FLOAT"), etc.). Supprimer la période puis la recharger rend le script idempotent : le relancer ne duplique pas les lignes. Le chargement par load_table_from_json passe par un job de chargement, plus adapté à un traitement quotidien que l'insertion ligne à ligne. Le point d'entrée run() calcule la période (les sept derniers jours), boucle sur les comptes, applique add_kpis puis replace_period.

Étape 5 : planifier l'exécution

Déployez run(request) comme fonction HTTP, puis créez une tâche Cloud Scheduler qui l'appelle chaque matin. Les options de la commande sont celles de la référence gcloud¹¹ :

gcloud scheduler jobs create http rapport-google-ads-quotidien \
  --location=europe-west1 \
  --schedule="0 6 * * *" \
  --time-zone="Europe/Brussels" \
  --uri="URL_DE_VOTRE_FONCTION" \
  --http-method=POST \
  --oidc-service-account-email="scheduler@VOTRE_PROJET.iam.gserviceaccount.com"

Le compte de service indiqué doit avoir le droit d'appeler la fonction. Sans fuseau horaire, la tâche s'exécute en UTC (valeur par défaut)¹¹. Les identifiants de l'API se passent par variables d'environnement (GOOGLE_ADS_JSON_KEY_FILE_PATH, GOOGLE_ADS_LOGIN_CUSTOMER_ID) et GoogleAdsClient.load_from_env().

Étape 6 : afficher le tableau de bord

Data Studio se branche sur une table BigQuery, comme Power BI, qui dispose d'un connecteur Google BigQuery en import ou en requête directe¹². Choisissez selon l'outil que vos équipes utilisent déjà. Si vous voulez déléguer la mise en place de vos rapports et le suivi de vos campagnes, découvrez l'offre de notre agence SEA, dont l'audit est gratuit.