Google Ads API avec Python : accès, connexion, requêtes et cas d'usage

Pour appeler la Google Ads API en Python : activez l'API dans un projet Google Cloud, demandez l'accès Explorer pour toucher des comptes réels, installez google-ads, mettez vos identifiants OAuth2 dans google-ads.yaml, puis interrogez vos comptes en GAQL avec search_stream. Le developer token n'est plus nécessaire depuis le 9 septembre 2026 : le niveau d'accès dépend désormais du projet Google Cloud qui détient vos identifiants¹. La version 33.0.0 de la bibliothèque, publiée le 23 septembre 2026, utilise par défaut la version v25 de l'API et accepte aussi v24 et v23⁶⁷. Ce tutoriel va de l'accès au premier appel, puis à trois cas d'usage : créer une campagne, piloter Performance Max, extraire des rapports.

À quoi sert l'API, et en avez-vous besoin ?

La Google Ads API est une porte d'entrée pour que vos propres logiciels lisent et modifient vos comptes Google Ads sans passer par l'écran. Elle sert surtout à trois choses : consolider les chiffres de plusieurs comptes dans un seul tableau de bord (voir automatiser vos rapports Google Ads), renvoyer à Google les ventes réellement conclues dans votre CRM (voir importer des conversions hors ligne) et créer ou ajuster des campagnes en série. Google indique que l'API est gratuite : ce sont le niveau d'accès et le temps de développement qui comptent². Pour une alerte ou un rapport simple dans un seul compte, les scripts Google Ads suffisent souvent : comparez-les dans Scripts ou API. Les limites chiffrées sont détaillées dans tarifs, quotas et limites.

Il faut écrire et maintenir du code : l'API n'est pas utilisable « sans développeur ». Si vous préférez déléguer, notre équipe de gestion de campagnes Google Ads présente l'accompagnement AdSim, audit gratuit compris.

Partie 1 : obtenir l'accès

Qu'est-ce qui a changé le 9 septembre 2026 ?

• Fin du developer token. Le niveau d'accès de votre ancien token a été transféré automatiquement à vos projets Google Cloud, sur la base de l'activité des 90 jours précédents. Envoyer encore le token dans l'en-tête est facultatif et ignoré ; Google annonce qu'il rejettera ce champ dans une future version majeure de l'API¹.
• Inscription et gestion des accès dans Google Cloud Console, sur la page de présentation de la Google Ads API (« Google Ads API Overview »). Les demandes faites depuis le Centre API d'un compte administrateur Google Ads ne sont plus traitées¹.
• Validation de la marque (brand verification) du projet Cloud obligatoire pour toute nouvelle demande Basic ou Standard¹.
• Compte administrateur (MCC) plus obligatoire : il ne sert que si vous gérez plusieurs comptes par l'API¹.
• Nouvelle erreur : en v25, un projet en accès Test qui appelle un compte réel reçoit AuthorizationError.CLOUD_PROJECT_NOT_APPROVED_FOR_PRODUCTION (ACTION_NOT_PERMITTED dans les versions antérieures)¹.

Le niveau d'accès s'applique au projet qui a servi à créer vos identifiants OAuth : le projet qui possède l'identifiant client OAuth (flux utilisateur) ou celui qui possède le compte de service. Vous pouvez avoir plusieurs projets avec des niveaux différents¹. Si vous aviez déjà un token, vérifiez sur la page de présentation de chaque projet que le niveau affiché correspond à l'ancien, et que les développeurs et responsables du compte ont un rôle propriétaire ou éditeur dans le projet : ces adresses recevront les annonces obligatoires de Google¹.

Quels niveaux d'accès existent ?

Sources : niveaux d'accès² et délais d'examen¹. Le « jour » est une fenêtre glissante de 24 heures. Au-delà du quota quotidien, chaque service garde ses propres limites de débit.

Comment activer l'API et demander l'accès ?

1. Dans Google Cloud Console, créez (ou choisissez) le projet qui portera vos identifiants OAuth2 : c'est lui qui détermine votre niveau d'accès¹.
2. Activez la Google Ads API dans ce projet : il passe en accès Test².
3. Développez contre un compte de test Google Ads.
4. Sur la page de présentation de la Google Ads API du projet, demandez l'accès Explorer pour appeler vos comptes réels².
5. Pour dépasser 2 880 opérations par jour, faites valider la marque du projet (écran de consentement OAuth), puis demandez Basic². Standard se justifie pour un outil qui gère de gros volumes.

Deux problèmes connus, signalés par Google sur sa page consacrée à la fin du developer token à la date du 7 octobre 2026¹. Une demande Explorer ou Basic peut être refusée alors que la marque est validée si le projet Cloud est en « Free trial » ou si son compte de facturation est suspendu ou désactivé : passer le projet en offre payante, ou utiliser un autre projet validé, contourne le problème. Et certains projets passés en Explorer, Basic ou Standard après le 9 septembre reçoivent AUTHORIZATION_ERROR sur les comptes réels : Google déploie un correctif et propose en attendant de demander l'accès Explorer avec un nouveau projet Cloud. Relisez cette page avant de conclure à une erreur de votre code.

Quel flux OAuth2 choisir ?

Configurez vos identifiants OAuth2 dans le même projet Cloud que celui où l'API est activée, sinon le niveau d'accès ne s'applique pas⁴.

• Compte de service : recommandé quand aucune personne n'intervient (scripts de reporting, automatisations serveur). Vous ajoutez l'adresse e-mail du compte de service comme utilisateur dans Google Ads (Administration, Accès et sécurité), avec le niveau d'accès nécessaire ; par défaut, il ne peut pas être administrateur. Une adresse peut être associée à 20 comptes au maximum : au-delà, ajoutez-la à un compte administrateur qui regroupe les autres³. Avantage : l'accès ne disparaît pas quand l'employé qui l'avait autorisé quitte l'entreprise.
• Utilisateur unique : si vos règles internes interdisent les comptes de service. Un utilisateur qui a accès à tous les comptes autorise l'application une fois, via la CLI gcloud (méthode recommandée par Google, avec use_application_default_credentials: true, à partir de la bibliothèque 28.3.0) ou l'exemple generate_user_credentials⁴⁵.
• Multi-utilisateur : pour une application où chaque client connecte lui-même son compte Google Ads⁴.

Pour générer un jeton d'actualisation (refresh token) avec la bibliothèque Python, le fichier JSON est celui de votre client OAuth, téléchargé depuis Cloud Console⁴ :

git clone https://github.com/googleads/google-ads-python.git
cd google-ads-python
python examples/authentication/generate_user_credentials.py -c /chemin/client_secret.json

Partie 2 : installer la bibliothèque et envoyer une première requête

De quoi avez-vous besoin avant d'écrire du code ?

• Python 3.9 à 3.14 : c'est la plage déclarée par le paquet sur PyPI⁷. Certaines pages de documentation citent encore Python 3.8, qui n'est plus accepté.
• Un projet Google Cloud avec la Google Ads API activée, au niveau d'accès voulu (voir la partie 1).
• Des identifiants OAuth2 : identifiant client, secret client et jeton d'actualisation ; ou un compte de service pour un programme sans intervention humaine⁵.
• L'identifiant du compte administrateur (login_customer_id) seulement si vous accédez aux comptes clients via un compte administrateur⁵.

Il vous faut aussi un compte Google Ads à interroger : pour en ouvrir un, voir créer un compte Google Ads en 5 étapes.

Quelle version de la bibliothèque correspond à quelle version de l'API ?

Installez la dernière version stable de la bibliothèque, et fixez la version d'API si vous voulez un comportement reproductible (voir plus bas). Chaque version d'API a une date d'arrêt : consultez les dates d'arrêt et la migration des versions. Avec une bibliothèque antérieure à 32.0.0, le fichier de configuration devait encore contenir un developer token : mettez plutôt la bibliothèque à jour⁶.

Comment installer la bibliothèque ?

python -m venv venv
source venv/bin/activate
python -m pip install --upgrade google-ads

Travaillez dans un environnement virtuel. Pandas ou BigQuery ne sont pas nécessaires pour ce tutoriel.

Comment configurer google-ads.yaml ?

Choisissez un seul groupe d'identifiants : compte de service (json_key_file_path), identifiants par défaut de l'application (use_application_default_credentials) ou jeton OAuth (client_id, client_secret, refresh_token)⁵.

# google-ads.yaml : utilisateur unique avec jeton d'actualisation
client_id: "VOTRE_CLIENT_ID.apps.googleusercontent.com"
client_secret: "VOTRE_CLIENT_SECRET"
refresh_token: "VOTRE_REFRESH_TOKEN"
login_customer_id: "1234567890"   # seulement via un compte administrateur, sans tirets
use_proto_plus: true

# google-ads.yaml : compte de service (recommandé sans interaction humaine)
json_key_file_path: /chemin/securise/cle-compte-de-service.json
login_customer_id: 1234567890   # ID du compte administrateur (MCC), sans tirets, si vous passez par un MCC
use_proto_plus: true

Le champ use_proto_plus est obligatoire : il choisit le type de messages renvoyés. Avec true, les objets se lisent comme des objets Python ordinaires, ce que suppose le code ci-dessous ; les messages protobuf, sans cette couche, sont plus rapides sur de gros volumes⁵. Si votre ancien fichier contient un developer_token, il n'est plus utilisé¹.

login_customer_id est obligatoire dès que votre accès à un compte passe par un compte administrateur : sans lui, l'appel échoue avec USER_PERMISSION_DENIED. N'ajoutez jamais ce fichier à Git : mettez-le dans .gitignore dès la création. Vous pouvez aussi charger la configuration depuis des variables d'environnement préfixées GOOGLE_ADS_ (par exemple GOOGLE_ADS_CLIENT_ID ou GOOGLE_ADS_JSON_KEY_FILE_PATH) avec GoogleAdsClient.load_from_env()⁵.

Comment tester la connexion ?

ListAccessibleCustomers ne demande pas d'identifiant client et ignore login_customer_id : il liste les comptes où l'utilisateur authentifié a un accès direct, pas toute la hiérarchie d'un compte administrateur. Ensuite, une requête GAQL sur un compte précis confirme que toute la chaîne d'accès fonctionne. Notez que la ressource customer ne renvoie qu'une ligne, celle du compte interrogé : elle ne sert pas à lister des comptes.

from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_storage("google-ads.yaml", version="v25")

# 1. Comptes auxquels les identifiants ont un accès direct (pas besoin de customer_id)
customer_service = client.get_service("CustomerService")
for resource_name in customer_service.list_accessible_customers().resource_names:
    print(resource_name)  # customers/1234567890

# 2. Une requête GAQL sur un compte précis
ga_service = client.get_service("GoogleAdsService")
query = """
    SELECT customer.id, customer.descriptive_name, customer.currency_code
    FROM customer
"""
for row in ga_service.search(customer_id="1234567890", query=query):
    print(row.customer.id, row.customer.descriptive_name, row.customer.currency_code)

Ce code reprend les appels documentés par Google ; il n'a pas été exécuté sur un compte réel.

Comment lancer une première requête de campagnes ?

from google.ads.googleads.client import GoogleAdsClient

client = GoogleAdsClient.load_from_storage("google-ads.yaml", version="v25")
ga_service = client.get_service("GoogleAdsService")

query = """
    SELECT campaign.id, campaign.name, campaign.status
    FROM campaign
    WHERE campaign.status != 'REMOVED'
    ORDER BY campaign.id
"""

customer_id = "1234567890"  # identifiant du compte, sans tirets
stream = ga_service.search_stream(customer_id=customer_id, query=query)

for batch in stream:
    for row in batch.results:
        print(f"{row.campaign.id} | {row.campaign.name} | {row.campaign.status.name}")

Le paramètre version="v25" fixe la version d'API ; sans lui, la bibliothèque utilise la plus récente qu'elle contient. GAQL (Google Ads Query Language) ressemble à du SQL : vous choisissez des champs, une ressource (FROM campaign), des filtres et un tri.

Search ou SearchStream : quelle différence ?

Les deux méthodes conviennent à la production⁸. Contrairement à ce que l'on lit souvent, search_stream n'est pas « obligatoire » pour les gros volumes.

Comment écrire des requêtes GAQL plus riches ?

query = """
    SELECT
      campaign.name,
      segments.device,
      segments.date,
      metrics.clicks,
      metrics.impressions,
      metrics.cost_micros,
      metrics.conversions,
      metrics.all_conversions_value
    FROM campaign
    WHERE segments.date DURING LAST_7_DAYS
      AND campaign.status IN ('ENABLED', 'PAUSED')
    ORDER BY metrics.cost_micros DESC
    LIMIT 100
"""

Quand un segment (segments.device, segments.date) figure dans le SELECT, les métriques sont ventilées par segment : une ligne par campagne, appareil et jour⁹. LAST_7_DAYS désigne les sept derniers jours sans compter aujourd'hui ; pour une période précise, utilisez BETWEEN '2026-09-01' AND '2026-09-30'⁹. Les coûts sont en micros : divisez cost_micros par 1 000 000. Pour bâtir un rapport automatisé de bout en bout, suivez notre méthode pour automatiser vos rapports Google Ads.

Comment gérer les erreurs ?

from google.ads.googleads.errors import GoogleAdsException

try:
    create_paused_search_campaign(client, customer_id, "Campagne test")  # fonction définie dans la partie 3
except GoogleAdsException as ex:
    print(f"Requête {ex.request_id} échouée : {ex.error.code().name}")
    for error in ex.failure.errors:
        print(f"  {error.message}")
        if error.location:
            for element in error.location.field_path_elements:
                print(f"    champ : {element.field_name}")

Conservez toujours l'identifiant de requête (request_id) : c'est lui que demandera le support de Google. Pour tracer les échanges avec l'API, la bibliothèque écrit dans un journal dédié (google.ads.googleads.client) auquel vous ajoutez un gestionnaire¹², voir la FAQ ci-dessous. Les erreurs d'accès les plus fréquentes¹ (voir aussi les références d'erreurs d'autorisation et d'authentification de la v25) :

Quelles précautions de sécurité ?

• Ne versionnez jamais google-ads.yaml ni la clé JSON d'un compte de service ; en production, passez par des variables d'environnement ou un gestionnaire de secrets.
• Donnez au compte de service le niveau d'accès minimal dans Google Ads (standard ou lecture seule pour du reporting).
• Révoquez les accès des applications tierces devenues inutiles depuis la page des autorisations de votre compte Google.

Partie 3 : cas d'usage

Créer une première campagne Search en pause

Le code ci-dessous crée un budget puis une campagne Search en pause. Essayez-le sur un compte de test.

import uuid

def create_paused_search_campaign(client, customer_id, name):
    budget_service = client.get_service("CampaignBudgetService")
    budget_operation = client.get_type("CampaignBudgetOperation")
    budget = budget_operation.create
    budget.name = f"Budget {name} {uuid.uuid4()}"
    budget.delivery_method = client.enums.BudgetDeliveryMethodEnum.STANDARD
    budget.amount_micros = 10_000_000  # 10 unités de la devise du compte par jour
    budget_response = budget_service.mutate_campaign_budgets(
        customer_id=customer_id, operations=[budget_operation]
    )

    campaign_service = client.get_service("CampaignService")
    campaign_operation = client.get_type("CampaignOperation")
    campaign = campaign_operation.create
    campaign.name = name
    campaign.advertising_channel_type = client.enums.AdvertisingChannelTypeEnum.SEARCH
    campaign.status = client.enums.CampaignStatusEnum.PAUSED
    campaign.campaign_budget = budget_response.results[0].resource_name
    client.copy_from(campaign.manual_cpc, client.get_type("ManualCpc"))
    campaign.network_settings.target_google_search = True
    campaign.network_settings.target_search_network = False
    campaign.contains_eu_political_advertising = (
        client.enums.EuPoliticalAdvertisingStatusEnum.DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
    )
    response = campaign_service.mutate_campaigns(
        customer_id=customer_id, operations=[campaign_operation]
    )
    print(f"Campagne créée : {response.results[0].resource_name}")

• Montants en micros. Un million de micros équivaut à une unité de la devise du compte.
• Campagne en pause. L'exemple officiel crée la campagne à l'état PAUSED pour éviter une diffusion immédiate, et recommande de l'activer une fois le ciblage et les annonces prêts¹⁰.
• Déclaration politique européenne obligatoire. Toute nouvelle campagne créée par l'API doit renseigner contains_eu_political_advertising ; sans elle, la création échoue avec l'erreur FieldError.REQUIRED¹¹.
• Pas de CPC optimisé. L'option enhanced_cpc_enabled que l'on voyait dans d'anciens tutoriels n'est plus proposée pour Search et Display depuis fin mars 2025 : les campagnes concernées sont passées en CPC manuel (aide Google Ads). L'exemple officiel crée un CPC manuel vide¹⁰.

Cette campagne n'a encore ni groupe d'annonces, ni mots-clés, ni annonce : elle ne diffusera rien tant que vous ne les ajoutez pas. Le code de lecture et de création ci-dessus a été exécuté le 30 septembre 2026 avec google-ads 33.0.0 sous Python 3.14, sur des réponses simulées : aucune requête n'a été envoyée à l'API, et les requêtes GAQL ont été contrôlées contre les définitions des champs v25.

Piloter Performance Max par l'API

Performance Max est le type de campagne automatisé de Google (Search, YouTube, Display et autres canaux depuis un seul ensemble d'éléments). L'API permet de la créer de bout en bout (budget, campagne, groupes d'éléments, signaux, critères), d'y ajouter jusqu'à 10 000 mots-clés à exclure et d'en extraire des rapports par canal, par élément et par terme de recherche. Deux limites restent : on ne peut pas désactiver un canal, et les exclusions d'emplacements se gèrent au niveau du compte. Pour la stratégie côté annonceur (budget, éléments, mesure), voyez notre guide Performance Max pour les PME belges ; ici, le code. Exemples vérifiés sur la documentation de la v25 : ils reprennent l'exemple officiel Python et n'ont pas été exécutés sur un compte réel.

Performance Max : comment la campagne est-elle structurée dans l'API ?

Une campagne Performance Max standard a besoin d'un budget, d'une campagne, d'éléments de campagne si les consignes de marque sont activées, d'au moins un groupe d'éléments (100 au maximum) et des éléments liés à ce groupe (structure des requêtes). Hors campagnes retail, le groupe d'éléments et tous ses liens vers les éléments minimaux doivent être créés dans la même requête : l'API refuse un groupe incomplet. D'où l'usage de GoogleAdsService.Mutate avec des ID temporaires négatifs, les ressources référencées étant créées avant celles qui les référencent.

• Type de canal : PERFORMANCE_MAX, sans sous-type (création d'une campagne).
• Enchères : uniquement MaximizeConversions (CPA cible facultatif) ou MaximizeConversionValue (ROAS cible facultatif, exprimé en ratio : 3,5 = 350 %). Pas de stratégie de portefeuille.
• Budget : non partagé, période DAILY (ou CUSTOM_PERIOD pour un budget total avec dates de début et de fin). Google recommande un budget quotidien d'au moins trois fois le coût par conversion (création du budget).
• Consignes de marque : activées par défaut sur les nouvelles campagnes depuis la v21 ; le nom de l'entreprise et les logos se lient alors à la campagne (CampaignAsset), pas au groupe d'éléments.

Performance Max : comment créer le budget et la campagne ?

# Réutilise le client créé plus haut : GoogleAdsClient.load_from_storage("google-ads.yaml", version="v25")
customer_id = "1234567890"
BUDGET_TMP, CAMPAIGN_TMP = -1, -2  # ID temporaires, résolus dans la même requête

# 1. Budget : quotidien et non partagé
budget_op = client.get_type("MutateOperation")
budget = budget_op.campaign_budget_operation.create
budget.resource_name = client.get_service("CampaignBudgetService").campaign_budget_path(customer_id, BUDGET_TMP)
budget.name = "PMax - Produits Belgique - budget"
budget.amount_micros = 50_000_000  # 50 EUR par jour en moyenne
budget.delivery_method = client.enums.BudgetDeliveryMethodEnum.STANDARD
budget.explicitly_shared = False

# 2. Campagne : type PERFORMANCE_MAX, sans sous-type
campaign_op = client.get_type("MutateOperation")
campaign = campaign_op.campaign_operation.create
campaign_service = client.get_service("CampaignService")
campaign.resource_name = campaign_service.campaign_path(customer_id, CAMPAIGN_TMP)
campaign.name = "PMax - Produits Belgique"
campaign.status = client.enums.CampaignStatusEnum.PAUSED
campaign.advertising_channel_type = client.enums.AdvertisingChannelTypeEnum.PERFORMANCE_MAX
campaign.bidding_strategy_type = client.enums.BiddingStrategyTypeEnum.MAXIMIZE_CONVERSION_VALUE
campaign.maximize_conversion_value.target_roas = 4.0  # ratio : 4.0 = ROAS de 400 %
campaign.campaign_budget = campaign_service.campaign_budget_path(customer_id, BUDGET_TMP)
campaign.contains_eu_political_advertising = (
    client.enums.EuPoliticalAdvertisingStatusEnum.DOES_NOT_CONTAIN_EU_POLITICAL_ADVERTISING
)
campaign.brand_guidelines_enabled = True  # nom et logo liés en CampaignAsset

# 3. Ajouter ici : CampaignAsset (nom, logo), AssetGroup + AssetGroupAsset (minimum requis),
#    critères de campagne (lieux, langues, exclusions), puis tout envoyer en une fois :
operations = [budget_op, campaign_op]  # + autres opérations, dans l'ordre des dépendances
response = client.get_service("GoogleAdsService").mutate(
    customer_id=customer_id, mutate_operations=operations
)

Le champ contains_eu_political_advertising figure dans l'exemple officiel : il déclare si la campagne diffuse de la publicité politique ciblant l'UE. Laissez la campagne en pause : c'est la seule entité de la requête dont le statut doit être défini. Ce code est volontairement partiel : les éléments et le groupe d'éléments sont à ajouter dans la même requête.

Performance Max : quels éléments un groupe d'éléments doit-il contenir ?

Source : exigences d'éléments de l'API. Chaque élément est d'abord créé via AssetService, puis lié par un AssetGroupAsset portant son field_type. Un rapport d'image non conforme renvoie ASPECT_RATIO_NOT_ALLOWED au moment du lien, pas à l'import. Les liens annexes et autres éléments non listés se lient à la campagne.

Performance Max : comment ajouter des signaux ?

Un AssetGroupSignal porte soit une audience (audience), soit un thème de recherche (search_theme) ; chaque signal s'ajoute individuellement. Ce sont des indications : Performance Max s'en sert pour trouver des impressions d'intention similaire ou plus forte, sans s'y limiter (signaux de groupe d'éléments). Les audiences se gèrent avec AudienceService. Les « audiences similaires » n'existent plus depuis 2023.

Performance Max : quelles exclusions sont possibles ?

Critères de campagne acceptés : calendrier, tranche d'âge, marque, appareil, mot-clé, langue, lieu, groupe de lieux et page web. Les critères marque et mot-clé ne s'utilisent qu'en négatif (critères de campagne). Attention au ciblage de langue : depuis septembre 2026, il n'est plus pris en charge sur les campagnes Search, et pour Performance Max sur les annonces diffusées dans Google Search, car les annonces s'adaptent à la langue des textes et des pages de destination ; la campagne Performance Max ne renvoie pas d'erreur, le réglage s'appliquant encore aux autres canaux¹.

• Mots-clés à exclure : jusqu'à 10 000 par campagne, appliqués à l'inventaire Search et Shopping uniquement (aide Google Ads).
• Marques : critère BRAND négatif, pour éviter de payer vos propres recherches de marque.
• Pages web : critère WEBPAGE négatif pour exclure des URL de l'extension d'URL finale. Depuis la v22, l'extension d'URL finale s'active ou se désactive via FINAL_URL_EXPANSION_TEXT_ASSET_AUTOMATION dans asset_automation_settings ; l'activer active aussi la personnalisation des textes (optimisations Performance Max).

criterion_service = client.get_service("CampaignCriterionService")
op = client.get_type("CampaignCriterionOperation")
criterion = op.create
criterion.campaign = client.get_service("CampaignService").campaign_path(customer_id, campaign_id)
criterion.negative = True
criterion.keyword.text = "gratuit"
criterion.keyword.match_type = client.enums.KeywordMatchTypeEnum.PHRASE
criterion_service.mutate_campaign_criteria(customer_id=customer_id, operations=[op])

Emplacements : pas d'exclusion au niveau de la campagne pour Performance Max, qui respecte en revanche les exclusions du compte et du compte administrateur (aide Google Ads). Dans l'API, elles passent par CustomerNegativeCriterion (URL, chaîne ou vidéo YouTube, application, liste d'emplacements) :

op = client.get_type("CustomerNegativeCriterionOperation")
op.create.placement.url = "example.com"
client.get_service("CustomerNegativeCriterionService").mutate_customer_negative_criteria(
    customer_id=customer_id, operations=[op]
)

Performance Max : quels rapports extraire ?

Performance Max n'a ni ad_group ni ad_group_ad : ces ressources ne renvoient rien pour ces campagnes. Trois requêtes couvrent l'essentiel (rapports Performance Max).

Performances par canal (v23 et suivantes) :

SELECT
  campaign.name,
  segments.ad_network_type,
  segments.ad_using_product_data,
  segments.ad_using_video,
  metrics.impressions,
  metrics.clicks,
  metrics.conversions,
  metrics.cost_micros
FROM campaign
WHERE campaign.advertising_channel_type = 'PERFORMANCE_MAX'
  AND segments.date DURING LAST_30_DAYS

performance_max_placement_view donne en plus les impressions par emplacement.

Termes de recherche :

SELECT
  campaign_search_term_view.search_term,
  metrics.impressions,
  metrics.clicks,
  metrics.cost_micros,
  metrics.conversions
FROM campaign_search_term_view
WHERE campaign.advertising_channel_type = 'PERFORMANCE_MAX'
  AND segments.date DURING LAST_30_DAYS

campaign_search_term_view est la ressource indiquée par Google pour les termes de recherche Performance Max. Évitez les segments liés aux mots-clés dans cette requête : ils excluent les données Performance Max.

Performances par élément :

SELECT
  asset_group_asset.asset,
  asset_group_asset.field_type,
  asset_group_asset.primary_status,
  segments.ad_network_type,
  metrics.impressions,
  metrics.clicks,
  metrics.conversions,
  metrics.conversions_value,
  metrics.cost_micros
FROM asset_group_asset
WHERE asset_group_asset.status = 'ENABLED'
  AND segments.date DURING LAST_30_DAYS

Les statistiques complètes (impressions, clics, conversions, coût) sont désormais disponibles par élément, en plus du statut principal. Pour les meilleures combinaisons, interrogez asset_group_top_combination_view.

Performance Max : quelles limites restent ?

• Aucun moyen de couper un canal (YouTube, Display…) dans une campagne Performance Max : si c'est indispensable, séparez en campagnes Search et Shopping standard.
• Exclusions d'emplacements au niveau du compte uniquement : elles touchent aussi vos autres campagnes.
• Mots-clés à exclure sans effet sur les canaux autres que Search et Shopping.

Et ensuite ?

Trois suites logiques : automatiser vos rapports (extraction, BigQuery, planification), importer vos ventes conclues et surveiller vos quotas. Une fois l'accès en place, planifiez aussi les montées de version : chaque version majeure est maintenue environ un an (voir migration entre versions et dates de fin). Pour intégrer ces appels à un projet plus large, notre page sur la gestion de campagnes Google Ads présente l'accompagnement AdSim, audit gratuit compris.