Guide 2026 : comment connecter Google Ads à Claude avec le MCP officiel

Connecter Google Ads à Claude devient une étape importante pour les entrepreneurs, consultants, agences marketing et profils growth qui veulent analyser leurs campagnes publicitaires plus vite. Jusqu’à récemment, il fallait ouvrir Google Ads, exporter des rapports, copier des données dans un tableur, puis demander à une IA de les interpréter. Avec un serveur MCP, Claude peut interroger directement une source externe structurée, comprendre les comptes accessibles, lire les campagnes, analyser les performances et répondre avec un contexte beaucoup plus précis.

Le sujet peut sembler technique au début, parce qu’il mélange plusieurs éléments : Claude Desktop, Claude Code, MCP, Google Ads API, OAuth, developer token, Google Cloud, pipx, parfois Cloud Run, et parfois une configuration JSON. Si tu lis tout ça d’un coup, c’est normal d’avoir l’impression que ça fait beaucoup.

Mais tu ne vas pas faire tout ça seul.

L’idée de ce guide est simple : tu vas utiliser Claude Code comme assistant technique pendant toute la mise en place. Au lieu de chercher toi-même quel fichier modifier, où mettre la configuration, quelle commande lancer ou pourquoi une erreur apparaît, tu vas demander à Claude Code de t’accompagner à chaque étape. Il va pouvoir vérifier ton environnement, préparer la configuration, te dire quoi copier, contrôler les erreurs et t’aider à comprendre ce qui se passe.

Tu gardes toujours la décision finale. Claude Code t’aide à avancer. Il ne doit pas recevoir tes secrets n’importe comment, il ne doit pas publier de campagne, et il ne doit pas faire une action sensible sans que tu comprennes ce qu’il prépare. Mais pour une configuration technique comme celle-ci, il peut vraiment te tenir la main.

Ce guide explique donc tout depuis zéro, mais avec une méthode plus simple : tu lis l’étape, tu copies le prompt dans Claude Code, tu le laisses vérifier, puis tu valides. L’objectif n’est pas seulement de donner une commande à copier. L’objectif est de comprendre ce que tu es en train de connecter, pourquoi le MCP officiel Google Ads fonctionne en lecture seule, quelle méthode choisir entre une installation locale et une connexion par URL, comment éviter les erreurs classiques, et comment utiliser Claude efficacement une fois la connexion active.

Il faut aussi clarifier un point dès le départ : le MCP officiel Google Ads ne crée pas de campagnes. Il est actuellement conçu pour la lecture, l’analyse, le reporting et la découverte des données. Il peut aider Claude à répondre à des questions comme : “Quelles campagnes ont le plus dépensé cette semaine ?”, “Quels comptes Google Ads ai-je accès ?”, “Comment se comporte cette campagne ?”, “Quels champs GAQL puis-je utiliser pour analyser les conversions ?”. En revanche, il ne va pas activer une campagne, modifier une enchère, créer une annonce, publier un asset ou changer un budget.

Et c’est plutôt une bonne chose. Google Ads peut dépenser de l’argent réel. Un outil qui permettrait à une IA de modifier directement les campagnes devrait avoir des garde-fous très stricts. Le MCP officiel Google Ads sert donc de socle fiable pour observer, comprendre et diagnostiquer. Pour automatiser la création ou la modification de campagnes, il faut ajouter une autre couche, par exemple un MCP writer custom ou communautaire, mais ce n’est pas le sujet principal de ce tutoriel.

Dans ce guide 2026, tu vas apprendre :

• ce qu’est le MCP Google Ads officiel ;
• ce qu’il peut faire et ne pas faire ;
• les prérequis Google Cloud et Google Ads API ;
• comment demander à Claude Code de t’aider à préparer l’installation ;
• comment connecter le MCP à Claude Desktop en local ;
• comment utiliser une URL distante si tu déploies le MCP sur Cloud Run ;
• comment tester la connexion dans Claude ;
• quels prompts utiliser pour analyser tes campagnes ;
• comment diagnostiquer les erreurs fréquentes ;
• quelle architecture choisir si tu veux aller plus loin.

Le guide est volontairement écrit de façon simple. Il ne suppose pas que tu sois développeur. Les parties techniques sont expliquées étape par étape, avec des exemples concrets, des tableaux, des checklists et des prompts prêts à copier dans Claude Code et dans Claude Desktop.

À retenir avant de commencer

Avant de rentrer dans les étapes !

Le MCP officiel Google Ads est un serveur qui permet à Claude de communiquer avec Google Ads API. Il expose des outils que Claude peut appeler pour lire les données de ton compte Google Ads. Il fonctionne avec l’authentification Google, un developer token Google Ads, et une configuration MCP dans Claude Desktop.

Il y a deux grandes façons de l’utiliser :

1. Installation locale : Claude Desktop lance le serveur MCP sur ton ordinateur avec pipx. C’est la méthode la plus simple pour démarrer.
2. Installation distante : tu héberges le MCP sur Google Cloud Run ou une autre infrastructure, puis tu connectes Claude avec une URL du type https://ton-service.a.run.app/mcp.

La méthode locale est parfaite pour une personne seule. La méthode distante devient intéressante si plusieurs outils ou personnes doivent utiliser le même serveur MCP.

Le serveur officiel, documenté dans le guide développeur Google Ads MCP et dans le repo GitHub officiel googleads/google-ads-mcp, expose principalement trois outils :

• list_accessible_customers pour lister les comptes Google Ads accessibles ;
• search pour exécuter des requêtes de lecture sur Google Ads ;
• get_resource_metadata pour comprendre les ressources et les champs disponibles.

Il expose aussi des ressources utiles comme les métriques et segments Google Ads API, les release notes et les documents de découverte de l’API. Ces ressources aident Claude à construire de meilleures requêtes et à mieux comprendre les données Google Ads.

La méthode la plus simple : se faire accompagner par Claude Code

Tu pourrais suivre ce tutoriel comme une documentation classique : lire une étape, ouvrir ton terminal, chercher le bon fichier, copier une commande, vérifier une erreur, recommencer. Ça fonctionne, mais ce n’est pas la méthode la plus confortable.

La méthode que je te recommande est différente : tu ouvres Claude Code et tu lui demandes de t’accompagner pendant toute la configuration.

Claude Code ne remplace pas Claude Desktop. Les deux outils n’ont pas exactement le même rôle :

• Claude Desktop sera l’application dans laquelle tu utiliseras Google Ads une fois le MCP connecté.
• Claude Code sera ton assistant technique pour préparer l’installation, vérifier ton Mac ou ton PC, modifier le fichier de configuration et t’aider à corriger les erreurs.

Autrement dit, Claude Code t’aide à installer la connexion. Claude Desktop utilise ensuite la connexion.

Ce changement rend le parcours beaucoup plus simple. Tu n’as plus besoin de retenir tous les chemins de fichiers. Tu peux demander à Claude Code :

• de vérifier si pipx est installé ;
• de trouver le chemin exact de pipx ;
• de t’aider à localiser claude_desktop_config.json ;
• de préparer le JSON correctement ;
• de vérifier si ton fichier JSON est valide ;
• de t’expliquer où coller ton Project ID et ton developer token ;
• de t’aider à relancer Claude Desktop ;
• de diagnostiquer une erreur si le MCP ne démarre pas.

Il y a seulement une règle importante : ne donne jamais tes secrets à l’aveugle. Si Claude Code te prépare un fichier, relis-le. Si tu dois ajouter un developer token, fais-le dans ton fichier local. Si une commande ouvre une page Google pour t’authentifier, vérifie bien le compte utilisé.

Le bon fonctionnement ressemble à ça :

Le parcours accompagné en cinq moments

Voici comment penser le parcours, sans te mettre la pression :

• Vérifier l’environnement : tu ouvres Claude Code, il vérifie pipx, gcloud, ton système et les chemins utiles. Toi, tu regardes ce qui manque.
• Préparer Google Cloud : tu crées ou choisis ton projet Google Cloud. Claude Code te donne la checklist exacte et les commandes utiles. Toi, tu confirmes le bon Project ID.
• Préparer OAuth : tu télécharges le fichier OAuth. Claude Code t’aide à lancer la commande gcloud avec les bons scopes. Toi, tu choisis le bon compte Google.
• Préparer Claude Desktop : Claude Code génère le JSON et vérifie qu’il est valide. Toi, tu ajoutes les valeurs sensibles et tu valides avant sauvegarde.
• Tester la connexion : tu redémarres Claude Desktop. Claude Code te donne les prompts de test et t’aide à lire les erreurs. Toi, tu confirmes que les comptes apparaissent.

Cette façon de travailler change tout. L’utilisateur n’est plus seul face à une documentation technique. Il avance avec un assistant qui peut lire les erreurs, vérifier les fichiers et expliquer quoi faire ensuite.

Le rôle exact du MCP dans cette connexion

MCP signifie Model Context Protocol. C’est un protocole qui permet à une application IA comme Claude de communiquer avec des outils externes. On peut voir MCP comme une prise universelle entre Claude et tes systèmes : fichiers, bases de données, CRM, outils internes, API métier ou plateformes publicitaires.

Sans MCP, Claude répond uniquement avec ce que tu lui donnes dans la conversation ou ce qu’il peut déduire de ses connaissances. Si tu lui demandes “analyse mes campagnes Google Ads”, il ne peut pas deviner tes chiffres. Tu dois copier-coller des exports ou résumer les données à la main.

Avec MCP, Claude peut découvrir des outils disponibles. Par exemple, il voit qu’il peut appeler un outil search du serveur Google Ads. Il peut alors demander au serveur MCP d’exécuter une requête Google Ads API pour récupérer des campagnes, des métriques, des statuts, des dépenses ou des conversions. Le serveur MCP se charge de parler à Google Ads API, de gérer l’authentification, puis de renvoyer les résultats à Claude sous une forme structurée.

Cette séparation est importante :

• Claude comprend la demande, raisonne, pose les bonnes questions et synthétise.
• Le MCP Google Ads exécute les appels autorisés vers Google Ads API.
• Google Ads API fournit les données du compte.
• Toi gardes le contrôle sur les credentials, les permissions et la configuration.

Le MCP n’est donc pas “une extension magique”. C’est une couche de connexion. Elle permet à Claude d’interagir avec Google Ads de façon plus propre qu’un simple copier-coller, mais elle respecte les limites fixées par le serveur.

Tableau 1 : les trois façons de connecter Google Ads à Claude

Méthode	Niveau de simplicité	Ce que ça permet	Quand la choisir
MCP officiel local avec pipx	Facile à moyen	Lire les comptes, campagnes, métriques et ressources Google Ads depuis Claude Desktop	Meilleur choix pour commencer seul, sur son Mac ou PC
MCP officiel distant avec httpUrl	Moyen à avancé	Utiliser une URL MCP hébergée sur Cloud Run ou serveur distant	Idéal si tu veux partager le MCP entre plusieurs environnements
MCP writer custom ou communautaire	Avancé	Créer ou modifier campagnes, budgets, annonces, mots-clés	À utiliser seulement avec garde-fous, validation humaine et création en pause

Cette distinction évite beaucoup de confusion. Quand on lit “connecter Google Ads à Claude”, on peut imaginer que Claude va tout faire : lire, créer, modifier, publier et optimiser. Dans la pratique, il faut séparer l’analyse et l’action.

Le MCP officiel couvre très bien la partie analyse. Pour l’action, il faut un autre serveur ou un développement spécifique.

Ce que le MCP officiel Google Ads peut faire

Le MCP officiel Google Ads sert principalement à transformer Claude en analyste publicitaire assisté par les données réelles du compte. Il peut aider à obtenir une vision claire, rapide et structurée des performances, en s’appuyant sur les champs disponibles dans Google Ads API et sur les requêtes GAQL.

Concrètement, c’est là que ça devient vraiment intéressant. Au lieu de demander à Claude de commenter un export CSV figé, tu peux lui demander de regarder le compte comme un analyste : période, campagne, appareil, coût, conversions, tendance, anomalie, priorité. C’est le moment où tu te dis vraiment : “ok, là c’est puissant”, parce que Claude ne part plus d’une intuition vague. Il part des données accessibles via le MCP.

Avec cette connexion, Claude peut par exemple :

• repérer les campagnes qui dépensent beaucoup sans générer assez de conversions, puis classer les urgences par niveau de risque ;
• comparer les performances par période pour voir si une baisse vient d’un vrai problème ou simplement d’un changement de volume ;
• analyser les campagnes par appareil, réseau ou date afin de trouver les zones où le budget se dilue ;
• identifier les campagnes qui ont un bon potentiel de scaling parce qu’elles combinent volume, conversions et coût acceptable ;
• sortir les campagnes qui semblent “propres” en surface, mais qui cachent un CPA trop élevé ou une baisse de taux de conversion ;
• préparer un audit mensuel clair avec les hausses, les baisses, les anomalies et les décisions à vérifier ;
• transformer une question vague comme “pourquoi ça marche moins bien ?” en vraie enquête : période, coût, clics, conversions, segmentation, hypothèses ;
• aider à construire une requête GAQL plus fiable en vérifiant les champs disponibles dans la référence des champs Google Ads API ;
• comparer plusieurs comptes accessibles depuis un MCC pour savoir où regarder en premier ;
• préparer une synthèse lisible pour un client ou une équipe sans passer deux heures à refaire un reporting manuel.

Ce que le MCP fait très bien, c’est enlever le travail manuel de récupération des données. Au lieu d’aller chercher un rapport, de télécharger un CSV, puis de l’expliquer à Claude, tu peux demander directement :

Analyse mes campagnes actives sur les 30 derniers jours. Identifie celles qui dépensent le plus, celles qui convertissent le moins, et donne-moi une priorité d’optimisation.

Si la connexion est bien configurée, Claude peut interroger le MCP, récupérer les données, puis produire une réponse argumentée.

Ce que le MCP officiel Google Ads ne peut pas faire

Le point le plus important du guide est ici : le MCP officiel Google Ads est read-only dans sa version actuelle. Cela veut dire qu’il ne modifie pas les comptes.

Il ne peut pas :

• créer une campagne ;
• activer une campagne ;
• mettre en pause une campagne ;
• créer un budget ;
• modifier une enchère ;
• créer une annonce responsive search ad ;
• uploader des assets ;
• ajouter des mots-clés ;
• supprimer des entités ;
• appliquer automatiquement des recommandations Google Ads.

Cette limite est normale pour un outil officiel destiné à être connecté à des modèles IA. Une erreur sur Google Ads peut coûter cher. Même une petite modification de ciblage ou de budget peut changer la dépense réelle du compte.

Pour cette raison, le MCP officiel doit être compris comme un outil de diagnostic. Il est excellent pour répondre à la question “que se passe-t-il dans mon compte ?”. Il n’est pas conçu pour répondre directement à la question “modifie mon compte maintenant”.

Si tu veux créer des campagnes depuis Claude, il faudra ajouter une solution writer. La bonne architecture consiste à laisser le MCP officiel analyser les données, puis à faire passer toute création par un outil séparé, avec des limites de budget, des dry-runs, des validations et une création en statut PAUSED.

Tableau 2 : outils et ressources du MCP officiel Google Ads

Élément	Type	Utilité concrète dans Claude	Exemple de demande
list_accessible_customers	Outil	Liste les comptes Google Ads accessibles par l’utilisateur authentifié.	“Quels comptes puis-je analyser aujourd’hui ?”
search	Outil	Interroge Google Ads API pour récupérer campagnes, coûts, clics, conversions et segments.	“Trouve les campagnes qui dépensent sans convertir.”
get_resource_metadata	Outil	Explique les champs disponibles sur une ressource comme campaign, ad_group ou customer.	“Quels champs utiliser pour analyser le CPA ?”
Ressources API	Ressource MCP	Donne à Claude du contexte sur les métriques, segments, release notes et découverte API.	“Aide-moi à construire une requête GAQL fiable.”

Ce tableau montre pourquoi le MCP est puissant même sans écriture. Il donne à Claude une capacité d’exploration qui évite beaucoup de tâtonnements. Claude peut d’abord lister les comptes, puis comprendre les ressources disponibles, puis exécuter des recherches de données.

Pourquoi utiliser Claude Desktop plutôt que Claude dans le navigateur

Claude Desktop est particulièrement adapté aux MCP locaux parce qu’il peut lancer un serveur sur ton ordinateur. L’application de bureau peut lire son fichier de configuration, démarrer un processus local, lui transmettre des variables d’environnement, puis faire apparaître le serveur dans les outils disponibles.

Claude dans le navigateur est pratique pour discuter, mais la logique MCP locale est historiquement plus naturelle côté Desktop. Avec Claude Desktop, tu peux configurer un serveur local dans un fichier claude_desktop_config.json, redémarrer l’application, puis utiliser le MCP dans une conversation.

La configuration locale ressemble à ceci :

{
  "mcpServers": {
    "google-ads-mcp": {
      "command": "pipx",
      "args": [
        "run",
        "--spec",
        "git+https://github.com/googleads/google-ads-mcp.git",
        "google-ads-mcp"
      ],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "PATH_TO_CREDENTIALS_JSON",
        "GOOGLE_PROJECT_ID": "YOUR_PROJECT_ID",
        "GOOGLE_ADS_DEVELOPER_TOKEN": "YOUR_DEVELOPER_TOKEN"
      }
    }
  }
}

Ce bloc dit à Claude : “Quand j’ai besoin du serveur google-ads-mcp, lance cette commande, avec ces arguments et ces variables d’environnement.” Claude ne contient pas Google Ads. Il lance un serveur MCP local qui, lui, sait communiquer avec Google Ads API.

Les prérequis indispensables

Avant de configurer Claude Desktop, il faut préparer Google. C’est souvent là que les gens bloquent. Le MCP lui-même est simple à lancer, mais Google Ads API exige une authentification correcte.

Tu as besoin de quatre grandes choses :

1. un projet Google Cloud ;
2. l’API Google Ads API activée dans ce projet ;
3. un developer token Google Ads ;
4. des credentials OAuth ou des Application Default Credentials qui donnent accès au compte Google Ads.

Ces éléments ne servent pas tous au même rôle.

Le projet Google Cloud sert de cadre technique. C’est là que tu actives Google Ads API et que tu crées les identifiants OAuth.

Le developer token vient de Google Ads, généralement via l’API Center d’un compte manager. Il identifie ton application ou ton intégration auprès de Google Ads API. Pour interroger des comptes de production, le token doit avoir un niveau d’accès suffisant, au minimum Explorer selon les indications du repo officiel Google Ads MCP.

Les credentials OAuth permettent de dire : “cet utilisateur Google précis autorise l’application à accéder à ses données Google Ads”. Le scope Google Ads important est :

https://www.googleapis.com/auth/adwords

Même si le serveur officiel est read-only, Google Ads API utilise ce scope. Le contrôle read-only vient des outils exposés par le serveur MCP, pas d’un scope Google Ads séparé plus limité.

Tableau 3 : prérequis, où les trouver et à quoi ils servent

Pré-requis	Où le trouver	À quoi ça sert	Erreur typique si absent
Google Cloud Project ID	Google Cloud Console	Identifier le projet qui porte l’API et les credentials	Le MCP démarre mais l’authentification échoue
Google Ads API activée	Google Cloud Console > APIs & Services	Autoriser les appels vers Google Ads API	Erreur API non activée
Developer token	Google Ads > API Center	Autoriser ton application à appeler Google Ads API	Erreur de developer token manquant ou limité
Credentials OAuth / ADC	Google Cloud + gcloud auth application-default login	Authentifier l’utilisateur qui a accès aux comptes Google Ads	Claude ne peut pas lister les comptes

Ce tableau est à garder sous les yeux. Si la connexion ne fonctionne pas, l’erreur vient presque toujours d’une de ces quatre lignes.

Étape 1 avec Claude Code : vérifier et installer pipx

Le repo officiel Google Ads MCP recommande une exécution via pipx. pipx permet de lancer des outils Python isolés sans polluer l’environnement Python global.

Ne commence pas par te demander quelle commande lancer. Demande d’abord à Claude Code de vérifier ton ordinateur. C’est son rôle ici : regarder l’environnement, te dire ce qui est déjà prêt, puis te guider calmement si quelque chose manque.

Vérifie si pipx est installé sur ma machine. Si oui, donne-moi son chemin exact. Si non, explique-moi la méthode d’installation la plus simple pour mon système. Ne modifie rien sans me prévenir avant.

Sur macOS, tu peux installer pipx avec Homebrew :

brew install pipx
pipx ensurepath

Ensuite, ferme et rouvre ton terminal si nécessaire.

Pour vérifier :

pipx --version

Si tu es sur Windows, tu peux installer pipx via Python. Le principe reste le même : Claude Desktop doit pouvoir exécuter la commande pipx depuis son environnement.

Un problème classique : pipx fonctionne dans ton terminal, mais pas depuis Claude Desktop. Cela arrive quand l’application Desktop n’a pas le même PATH que ton terminal. Dans ce cas, tu peux utiliser le chemin absolu de pipx dans la configuration, par exemple :

which pipx

Puis remplacer "command": "pipx" par le chemin retourné.

Si tu ne comprends pas le résultat, ne bloque pas. Copie simplement la sortie dans Claude Code :

Voici le résultat de la commande which pipx et/ou pipx --version : COLLE_ICI_LE_RÉSULTAT. Dis-moi si tout est bon pour continuer ou si je dois corriger quelque chose.

Étape 2 avec Claude Code : préparer le projet Google Cloud

Va dans Google Cloud Console, crée un projet ou utilise un projet existant. L’important est d’avoir le Project ID, pas seulement le nom affiché.

Ici, Claude Code ne va pas cliquer à ta place dans ton compte Google. En revanche, il peut te dire exactement quoi chercher, dans quel ordre, et quoi noter. Tu avances plus tranquillement.

Je dois préparer un projet Google Cloud pour connecter le MCP officiel Google Ads à Claude Desktop. Guide-moi simplement : quelle page ouvrir, quelle API activer, quel Project ID récupérer, et comment vérifier que je ne confonds pas Project ID, customer ID et manager ID.

Le Project ID ressemble souvent à :

mon-projet-ads-123456

Dans ce projet, active Google Ads API. Sans cette activation, les credentials peuvent exister mais les appels échoueront.

Tu peux aussi le faire avec gcloud si tu préfères :

gcloud config set project YOUR_PROJECT_ID

Puis active l’API depuis la console ou via les commandes Google Cloud si tu es habitué.

À ce stade, ne confonds pas :

• Google Cloud Project ID : projet technique ;
• Google Ads Customer ID : compte publicitaire ;
• Google Ads Manager ID : compte manager/MCC ;
• Developer token : jeton API Google Ads.

Ce sont quatre identifiants différents.

Quand tu as ton Project ID, donne-le à Claude Code :

Mon Google Cloud Project ID est COLLE_ICI_TON_PROJECT_ID. Garde-le pour la configuration MCP. Ne crée pas encore le fichier final tant que je ne t’ai pas donné les autres éléments.

Étape 3 avec Claude Code : récupérer le developer token Google Ads

Le developer token se récupère dans Google Ads, généralement dans un compte manager. C’est une clé obligatoire pour utiliser Google Ads API.

Cette étape est sensible, parce que le developer token est une information importante. Claude Code peut t’expliquer où le trouver, mais tu dois garder la main sur la valeur. L’idée est simple : Claude Code prépare l’emplacement, toi tu colles le token dans ton fichier local.

Explique-moi comment récupérer un developer token Google Ads dans l’API Center. Dis-moi aussi quel niveau d’accès est nécessaire pour lire des comptes de production avec le MCP officiel Google Ads. Je veux une explication simple, étape par étape.

Pour un usage de test, tu peux commencer avec un niveau limité. Pour lire des comptes de production, le repo officiel indique qu’il faut au moins un accès Explorer. Si ton token ne peut interroger que des comptes de test, tu verras une erreur du type : le developer token est seulement approuvé pour les comptes test.

Voici la logique simple :

• Test access : utile pour tester avec des comptes de test ;
• Explorer access : requis pour interroger des comptes de production en lecture ;
• Basic ou Standard access : plus adapté aux applications qui font beaucoup d’opérations ou des mutations à plus grande échelle.

Pour le MCP officiel, l’objectif est la lecture et l’analyse. Tu n’as donc pas besoin de viser tout de suite une architecture lourde. Il faut surtout que le token permette de consulter les comptes que tu veux analyser.

Quand tu as le token, ne le colle pas dans un document public. Demande plutôt à Claude Code de préparer un placeholder :

Prépare-moi la configuration avec GOOGLE_ADS_DEVELOPER_TOKEN en placeholder. Je collerai moi-même la vraie valeur dans le fichier local.

Étape 4 avec Claude Code : créer les credentials OAuth

Pour que Claude puisse accéder aux données Google Ads via le MCP, le serveur doit avoir des credentials Google valides.

La méthode la plus simple en local est d’utiliser Application Default Credentials. Tu télécharges un client OAuth depuis Google Cloud, puis tu lances une commande gcloud qui crée un fichier local d’authentification.

Cette étape est souvent celle qui fait le plus peur, parce qu’elle parle de scopes, de fichier JSON et de gcloud. Là encore, demande à Claude Code de te préparer la commande et de t’expliquer chaque morceau.

Aide-moi à créer les Application Default Credentials pour Google Ads API. Vérifie d’abord si gcloud est installé. Ensuite, prépare la commande avec le scope https://www.googleapis.com/auth/adwords et explique-moi à quoi sert chaque partie avant que je l’exécute.

Le repo officiel donne une commande de ce type :

gcloud auth application-default login \
  --scopes https://www.googleapis.com/auth/adwords,https://www.googleapis.com/auth/cloud-platform \
  --client-id-file=YOUR_CLIENT_JSON_FILE

YOUR_CLIENT_JSON_FILE correspond au fichier JSON OAuth téléchargé depuis Google Cloud. Le navigateur s’ouvre, tu te connectes avec le compte Google qui a accès à Google Ads, puis gcloud enregistre un fichier de credentials.

À la fin, tu dois voir un message ressemblant à :

Credentials saved to file: /Users/tonnom/.config/gcloud/application_default_credentials.json

Garde ce chemin. Il va dans la variable :

GOOGLE_APPLICATION_CREDENTIALS

Si tu changes de compte Google, si tu révoques l’accès, ou si tu utilises un autre utilisateur, il faudra refaire cette étape.

Après la commande, donne le chemin obtenu à Claude Code :

Le fichier de credentials a été enregistré ici : COLLE_ICI_LE_CHEMIN. Vérifie que ce chemin est absolu et prépare-le pour la variable GOOGLE_APPLICATION_CREDENTIALS.

Étape 5 avec Claude Code : trouver le fichier Claude Desktop

Sur macOS, le fichier est :

~/Library/Application Support/Claude/claude_desktop_config.json

Sur Windows, il est généralement :

%APPDATA%\Claude\claude_desktop_config.json

La méthode la plus simple consiste à passer par l’interface :

Claude Desktop > Settings > Developer > Edit Config

Si le fichier n’existe pas, Claude peut le créer. S’il existe déjà, attention à ne pas supprimer les autres serveurs MCP que tu utilises.

Ne cherche pas ce fichier à la main si tu n’es pas à l’aise. Demande à Claude Code de le trouver et de regarder s’il contient déjà d’autres MCP.

Trouve le fichier claude_desktop_config.json de Claude Desktop sur ma machine. S’il n’existe pas, dis-moi où il doit être créé. S’il existe déjà, lis-le et explique-moi sa structure sans supprimer les serveurs MCP déjà présents.

La structure générale est toujours :

{
  "mcpServers": {
    "nom-du-serveur": {
      "command": "commande",
      "args": [],
      "env": {}
    }
  }
}

Le piège classique est d’ajouter un deuxième bloc mcpServers au lieu d’ajouter un serveur dans le bloc existant. Un JSON ne peut pas avoir deux clés identiques au même niveau sans créer de confusion.

Avant toute modification, demande une sauvegarde :

Avant de modifier claude_desktop_config.json, crée une copie de sauvegarde dans le même dossier avec la date dans le nom. Ensuite seulement, prépare l’ajout du serveur google-ads-mcp.

Étape 6 avec Claude Code : générer la configuration Google Ads MCP

Voici la configuration locale complète pour Claude Desktop.

À ce stade, tu as normalement plusieurs morceaux : le chemin des credentials, le Project ID, le developer token, et éventuellement le manager customer ID. Claude Code peut assembler tout ça proprement dans le bon format JSON.

Génère la configuration MCP officielle Google Ads pour Claude Desktop. Utilise le serveur googleads/google-ads-mcp, la commande pipx, mon Project ID, mon chemin GOOGLE_APPLICATION_CREDENTIALS, et laisse GOOGLE_ADS_DEVELOPER_TOKEN en placeholder pour que je colle la vraie valeur moi-même. Vérifie que le JSON final est valide.

{
  "mcpServers": {
    "google-ads-mcp": {
      "command": "pipx",
      "args": [
        "run",
        "--spec",
        "git+https://github.com/googleads/google-ads-mcp.git",
        "google-ads-mcp"
      ],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/Users/tonnom/.config/gcloud/application_default_credentials.json",
        "GOOGLE_PROJECT_ID": "ton-project-id",
        "GOOGLE_ADS_DEVELOPER_TOKEN": "ton-developer-token"
      }
    }
  }
}

Remplace :

• /Users/tonnom/.config/gcloud/application_default_credentials.json par ton vrai chemin ;
• ton-project-id par le Project ID Google Cloud ;
• ton-developer-token par ton developer token Google Ads.

Si tu utilises un compte manager Google Ads, ajoute :

"GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890"

La version avec manager account devient :

{
  "mcpServers": {
    "google-ads-mcp": {
      "command": "pipx",
      "args": [
        "run",
        "--spec",
        "git+https://github.com/googleads/google-ads-mcp.git",
        "google-ads-mcp"
      ],
      "env": {
        "GOOGLE_APPLICATION_CREDENTIALS": "/Users/tonnom/.config/gcloud/application_default_credentials.json",
        "GOOGLE_PROJECT_ID": "ton-project-id",
        "GOOGLE_ADS_DEVELOPER_TOKEN": "ton-developer-token",
        "GOOGLE_ADS_LOGIN_CUSTOMER_ID": "1234567890"
      }
    }
  }
}

Utilise de préférence les IDs Google Ads sans tirets. Par exemple :

1234567890

Plutôt que :

123-456-7890

Avant de sauvegarder, demande une dernière vérification :

Vérifie le JSON complet de claude_desktop_config.json. Assure-toi qu’il n’y a qu’un seul bloc mcpServers, que les virgules sont correctes, que les chemins sont absolus, et que le serveur google-ads-mcp ne remplace pas mes autres MCP.

Étape 7 avec Claude Code : redémarrer Claude Desktop et contrôler le démarrage

Après avoir modifié le fichier de configuration, quitte complètement Claude Desktop puis relance-le.

Il ne suffit pas toujours de fermer la fenêtre. Il faut vraiment quitter l’application, puis la rouvrir. Sur macOS :

Claude > Quit Claude

Ensuite, rouvre Claude Desktop et démarre une nouvelle conversation.

Claude Code peut te donner une petite checklist de redémarrage. C’est utile parce qu’une erreur peut venir simplement du fait que Claude Desktop n’a pas relu le fichier.

Je viens de modifier claude_desktop_config.json. Donne-moi la checklist de redémarrage de Claude Desktop et les premiers signes qui montrent que le MCP Google Ads est bien chargé.

Tu peux tester avec une question très simple :

Qu’est-ce que le serveur Google Ads MCP peut faire ?

Puis :

Quels comptes Google Ads ai-je accès ?

Si tout est bien configuré, Claude devrait détecter le serveur MCP et utiliser l’outil approprié pour lister les comptes.

Étape 8 avec Claude Desktop : tester avec un premier audit simple

Une fois la connexion active, commence toujours par des demandes simples. Ne demande pas tout de suite un audit complet de 90 jours avec segmentation avancée. Vérifie d’abord que le serveur voit tes comptes.

Ici, tu changes d’outil. Claude Code t’a aidé à installer. Maintenant, Claude Desktop utilise le MCP.

Prompt de test :

Liste les comptes Google Ads accessibles via le MCP Google Ads. Donne-moi les IDs de comptes et indique si tu as besoin d’un customer ID précis pour continuer.

Ensuite, choisis un compte et demande :

Pour le customer ID 1234567890, liste les campagnes actives avec leur nom, leur statut, leur coût, leurs clics, leurs impressions et leurs conversions sur les 30 derniers jours.

Si cette requête marche, la connexion est fonctionnelle.

Tu peux ensuite passer à des analyses plus utiles :

Analyse les campagnes du compte 1234567890 sur les 30 derniers jours. Classe-les par priorité d’optimisation. Je veux savoir où le budget est mal utilisé, quelles campagnes semblent performantes, et quelles questions je dois vérifier avant de modifier quoi que ce soit.

L’intérêt de Claude n’est pas seulement de lister les chiffres. L’intérêt est de transformer les données en diagnostic lisible.

Si ça ne marche pas, retourne dans Claude Code avec l’erreur exacte :

Claude Desktop ne parvient pas à utiliser le MCP Google Ads. Voici le message d’erreur : COLLE_ICI_L_ERREUR. Aide-moi à diagnostiquer calmement : fichier JSON, pipx, credentials, developer token, Project ID, login customer ID ou accès Google Ads.

Comment connecter avec une simple URL

Tu as demandé s’il était possible de mettre juste une URL du MCP dans Claude Desktop. La réponse est : oui, mais seulement si le serveur MCP est déjà hébergé quelque part.

Une URL GitHub ne suffit pas. Tu ne peux pas mettre :

https://github.com/googleads/google-ads-mcp

et espérer que Claude l’exécute. GitHub contient le code source, pas un serveur MCP actif pour ton compte.

En revanche, si tu déploies le MCP sur Cloud Run, tu peux obtenir une URL de service :

https://your-cloud-run-url.a.run.app/mcp

La configuration distante ressemble à :

{
  "mcpServers": {
    "google-ads-mcp": {
      "httpUrl": "https://your-cloud-run-url.a.run.app/mcp"
    }
  }
}

Cette méthode est plus propre si tu veux centraliser le serveur, mais elle ajoute des étapes : image Docker, Artifact Registry, Cloud Build, Cloud Run, OAuth proxy, variables d’environnement et URL publique.

Pour une première installation, la méthode locale reste plus simple.

Quand choisir Cloud Run

Cloud Run est utile si tu veux que le MCP tourne comme un vrai service web. Au lieu que Claude Desktop lance pipx sur ton ordinateur, Claude se connecte à une URL.

Cette approche a du sens si :

• tu veux partager le même MCP entre plusieurs machines ;
• tu veux une intégration plus stable pour une équipe ;
• tu veux éviter de dépendre d’un ordinateur local ;
• tu veux connecter plusieurs clients MCP au même service ;
• tu as l’habitude de Google Cloud ;
• tu veux une architecture plus professionnelle.

En revanche, Cloud Run n’est pas forcément le meilleur choix si tu débutes. Il faut gérer plus de sécurité, plus de configuration, plus de variables et plus de responsabilités.

Le repo officiel précise que le déploiement distant repose sur l’OAuth proxy. Cela veut dire que tu dois configurer :

• GOOGLE_ADS_MCP_OAUTH_CLIENT_ID ;
• GOOGLE_ADS_MCP_OAUTH_CLIENT_SECRET ;
• GOOGLE_ADS_MCP_BASE_URL ;
• GOOGLE_PROJECT_ID ;
• GOOGLE_ADS_DEVELOPER_TOKEN ;
• FASTMCP_HOST=0.0.0.0.

Une fois le service déployé, tu connectes Claude à l’URL /mcp.

Tableau 4 : installation locale ou URL distante

Critère	Local avec pipx	Distant avec Cloud Run
Simplicité de départ	Plus simple	Plus technique
Dépendance à ton ordinateur	Oui, Claude lance le MCP localement	Non, le serveur tourne dans le cloud
Partage en équipe	Peu pratique	Plus adapté
Sécurité à gérer	Principalement locale	Plus large : service web, URL, OAuth proxy, variables cloud
Meilleur cas d’usage	Solo, test, consultant, audit rapide	Agence, équipe, environnement durable
Configuration Claude	command, args, env	httpUrl

Si tu veux aller vite, commence en local. Si tu veux industrialiser, passe ensuite à Cloud Run.

La meilleure structure de prompts pour Google Ads

Une fois le MCP connecté, la qualité des réponses dépend beaucoup de la qualité des prompts. Claude peut lire les données, mais il faut lui donner un cadre d’analyse.

Un mauvais prompt ressemble à :

Analyse mes pubs.

Ce prompt est trop vague. Claude ne sait pas quelle période, quel compte, quels objectifs, quelles métriques et quelle profondeur d’analyse tu attends.

Un bon prompt donne :

• le compte ;
• la période ;
• l’objectif business ;
• les métriques importantes ;
• le format attendu ;
• les contraintes ;
• le niveau de décision.

Exemple :

Analyse le compte Google Ads 1234567890 sur les 30 derniers jours. Mon objectif principal est la génération de leads qualifiés. Classe les campagnes en trois catégories : à conserver, à surveiller, à corriger rapidement. Pour chaque campagne, indique le coût, les conversions, le CPA, le taux de conversion si disponible, puis donne une action recommandée. Ne propose aucune modification automatique, je veux uniquement un diagnostic.

Ce prompt est beaucoup plus exploitable. Il donne un cadre, une période, un objectif et une limite claire.

Prompts à copier pour démarrer

Voici une série de prompts prêts à copier dans Claude Desktop après connexion du MCP Google Ads.

Prompt 1 : vérifier la connexion

Liste les comptes Google Ads accessibles avec le serveur MCP Google Ads. Si aucun compte n’est accessible, explique-moi les causes possibles : credentials, developer token, login customer ID, droits Google Ads ou API non activée.

Prompt 2 : audit rapide des campagnes

Pour le customer ID 1234567890, analyse les campagnes actives sur les 30 derniers jours. Donne-moi un tableau de synthèse avec campagne, coût, clics, impressions, conversions, CPA et statut. Ensuite, classe les campagnes par priorité d’optimisation.

Prompt 3 : trouver les dépenses inutiles

Cherche les campagnes qui ont dépensé de l’argent sur les 30 derniers jours sans générer de conversions. Pour chaque campagne, indique le coût, les clics, les impressions, le CTR si disponible, puis propose les vérifications à faire avant de réduire le budget.

Prompt 4 : analyser la performance semaine par semaine

Compare les performances Google Ads de cette semaine avec la semaine précédente pour le customer ID 1234567890. Je veux voir les variations de coût, clics, conversions, CPA et taux de conversion. Termine par trois hypothèses expliquant les plus grosses variations.

Prompt 5 : construire une requête GAQL

Aide-moi à construire une requête GAQL pour obtenir les campagnes, coûts, clics, conversions et CPA sur les 30 derniers jours. Vérifie d’abord les champs disponibles avec les ressources du MCP si nécessaire, puis propose la requête.

Prompt 6 : audit orienté lead generation

Analyse le compte 1234567890 comme si tu étais un consultant Google Ads spécialisé en génération de leads B2B. Je veux un diagnostic clair : ce qui fonctionne, ce qui gaspille du budget, ce qui manque comme données, et les prochaines questions à poser avant de modifier les campagnes.

Prompt 7 : préparer une réunion client

Prépare un résumé client de la performance Google Ads sur les 30 derniers jours. Le ton doit être simple, professionnel et non technique. Structure la réponse en : résumé exécutif, points positifs, points d’attention, recommandations, prochaines étapes.

Prompt 8 : analyse avant optimisation

Avant toute optimisation, vérifie les données disponibles dans le compte 1234567890. Dis-moi quelles métriques sont fiables, lesquelles manquent, et quelles analyses seraient risquées sans contexte supplémentaire. Ne donne pas encore de recommandations de modification.

Ces prompts sont volontairement cadrés. Ils évitent que Claude parte dans une analyse trop générale.

Comment obtenir une analyse vraiment utile

La connexion MCP donne accès aux données, mais elle ne remplace pas la stratégie. Pour obtenir de bonnes réponses, il faut donner à Claude le contexte business.

Par exemple, une campagne peut avoir un CPA élevé, mais rester rentable si la valeur du lead est forte. À l’inverse, une campagne peut avoir beaucoup de conversions à faible coût, mais générer des leads de mauvaise qualité.

Avant de demander un audit, donne à Claude :

• ton type d’activité ;
• ton objectif principal ;
• la valeur moyenne d’un lead ;
• la valeur moyenne d’un client ;
• les zones géographiques ciblées ;
• les campagnes prioritaires ;
• les conversions que tu considères fiables ;
• les campagnes à ne pas toucher ;
• la période à analyser ;
• les événements récents importants.

Exemple :

Contexte : je vends des prestations d’automatisation IA à des PME françaises. Un lead qualifié vaut environ 80 euros pour moi, et mon CPA cible est de 35 euros. Les conversions les plus fiables sont les formulaires de demande de démo. Ignore les micro-conversions. Analyse maintenant les campagnes du compte 1234567890 sur les 30 derniers jours.

Avec ce contexte, Claude ne lit plus seulement des métriques. Il peut les interpréter par rapport à un objectif économique.

Les erreurs fréquentes à éviter

La première erreur consiste à oublier que le MCP officiel est read-only. Beaucoup d’utilisateurs s’attendent à pouvoir dire : “crée une campagne Google Ads”. Avec l’officiel, Claude peut aider à préparer la stratégie, mais pas publier la campagne.

La deuxième erreur consiste à confondre les IDs. Google Ads utilise plusieurs identifiants. Si tu mets le customer ID à la place du project ID, ou le manager ID au mauvais endroit, la connexion échoue.

La troisième erreur consiste à utiliser un developer token limité aux comptes test pour analyser un vrai compte de production. Dans ce cas, Google Ads API bloque l’accès.

La quatrième erreur consiste à oublier le scope OAuth https://www.googleapis.com/auth/adwords. Les credentials peuvent exister, mais ne pas avoir le bon scope.

La cinquième erreur consiste à modifier claude_desktop_config.json avec un JSON invalide. Une virgule en trop, une accolade manquante ou deux blocs mcpServers peuvent empêcher Claude de charger les serveurs.

La sixième erreur consiste à ne pas redémarrer Claude Desktop après modification.

La septième erreur consiste à attendre une analyse parfaite sans préciser la période ou l’objectif business.

Dépannage avec Claude Code : Claude ne voit pas le serveur MCP

Si Claude Desktop ne voit pas le serveur, commence par vérifier le fichier JSON.

Le plus simple est de ne pas chercher seul. Copie l’erreur ou décris ce que tu vois à Claude Code :

Claude Desktop ne voit pas mon serveur google-ads-mcp. Aide-moi à vérifier étape par étape : fichier JSON, chemin de pipx, structure mcpServers, redémarrage de Claude Desktop et logs éventuels. Explique-moi simplement ce que tu vérifies.

Un JSON valide doit :

• commencer par { ;
• finir par } ;
• avoir des guillemets doubles autour des clés ;
• ne pas avoir de virgule finale après le dernier élément ;
• ne pas contenir de commentaires ;
• avoir un seul bloc mcpServers.

Ensuite, vérifie que pipx est accessible.

Dans ton terminal :

which pipx
pipx --version

Si pipx n’est pas trouvé, installe-le. S’il est trouvé mais Claude ne le trouve pas, utilise le chemin absolu dans command.

Exemple :

"command": "/opt/homebrew/bin/pipx"

ou :

"command": "/usr/local/bin/pipx"

Selon ton installation.

Vérifie aussi que tu as bien quitté et relancé Claude Desktop.

Dépannage avec Claude Code : erreur de credentials Google

Si Claude voit le serveur mais n’arrive pas à récupérer les comptes, le problème vient souvent des credentials.

Dans ce cas, Claude Code peut t’aider à vérifier les chemins et les scopes sans avoir besoin de voir tes secrets.

Le MCP Google Ads démarre, mais Claude Desktop n’arrive pas à lister mes comptes. Aide-moi à vérifier les credentials : chemin GOOGLE_APPLICATION_CREDENTIALS, scope adwords, compte Google utilisé, API activée, developer token et niveau d’accès. Ne me demande pas de coller de secret complet.

Vérifie :

• le fichier GOOGLE_APPLICATION_CREDENTIALS existe ;
• le chemin est absolu ;
• le compte Google utilisé a accès au compte Google Ads ;
• le scope adwords a été demandé ;
• le projet Google Cloud a Google Ads API activée ;
• le developer token est correct ;
• le token a le bon niveau d’accès.

Tu peux refaire l’authentification ADC :

gcloud auth application-default login \
  --scopes https://www.googleapis.com/auth/adwords,https://www.googleapis.com/auth/cloud-platform \
  --client-id-file=YOUR_CLIENT_JSON_FILE

Puis remets le nouveau chemin dans Claude si nécessaire.

Dépannage avec Claude Code : erreur de manager account

Si ton compte Google Ads est accessible via un MCC, ajoute GOOGLE_ADS_LOGIN_CUSTOMER_ID.

Cette partie est souvent confuse, parce que le compte manager et le compte client ne sont pas le même identifiant. Claude Code peut t’aider à clarifier la différence.

Explique-moi la différence entre GOOGLE_ADS_LOGIN_CUSTOMER_ID et le customer ID du compte Google Ads à analyser. Aide-moi à vérifier où mettre l’ID du manager account dans la configuration MCP.

Exemple :

"GOOGLE_ADS_LOGIN_CUSTOMER_ID": "9876543210"

Le login customer ID doit être le compte manager par lequel l’accès est fait, pas forcément le compte final que tu veux analyser.

Ensuite, dans tes prompts, tu peux utiliser le customer ID du compte client :

Analyse le customer ID 1234567890 sur les 30 derniers jours.

Cette distinction est importante. Le login customer ID sert au routage de l’appel API. Le customer ID sert à dire quel compte publicitaire tu veux lire.

Dépannage : Claude répond sans utiliser le MCP

Parfois Claude répond de façon générale au lieu d’appeler le MCP. Dans ce cas, demande explicitement :

Utilise le serveur MCP Google Ads connecté à cette conversation. Commence par appeler l’outil qui liste les comptes accessibles, puis attends mon choix de customer ID.

Ou :

Ne réponds pas avec des généralités. Utilise le MCP Google Ads pour récupérer les données réelles du compte 1234567890, puis base ton analyse uniquement sur ces données.

Cela force Claude à distinguer une réponse théorique d’une analyse connectée.

Comment utiliser get_resource_metadata

L’outil get_resource_metadata est sous-estimé. Il sert à comprendre la structure des ressources Google Ads API.

Par exemple, tu peux demander :

Utilise get_resource_metadata pour la ressource campaign. Explique-moi les champs importants pour analyser les campagnes, puis propose une requête pour récupérer les performances des 30 derniers jours.

Cette approche est utile si tu veux éviter les requêtes GAQL invalides. Google Ads API a beaucoup de champs, et tous les champs ne sont pas compatibles avec toutes les ressources ou tous les segments.

Claude peut donc procéder en deux temps :

1. découvrir la ressource ;
2. construire la requête ;
3. exécuter la recherche ;
4. analyser les résultats.

C’est plus fiable que de demander directement une requête complexe.

Comment structurer un audit complet Google Ads avec Claude

Un audit Google Ads utile ne se limite pas à “quelles campagnes dépensent le plus”. Il faut regarder la cohérence globale du compte.

Voici une structure d’audit que tu peux demander à Claude :

• Vue globale : dépenses, clics, impressions, conversions, CPA ;
• Campagnes actives : statut, budget, performance ;
• Campagnes sous-performantes : coût élevé, conversions faibles ;
• Campagnes performantes : potentiel de scaling ;
• Segmentation temporelle : évolution semaine par semaine ;
• Segmentation appareil : desktop, mobile, tablette ;
• Analyse des conversions : qualité et fiabilité ;
• Questions à vérifier : tracking, landing pages, ciblage, budget ;
• Priorités d’action : urgent, important, à surveiller ;
• Risques : données insuffisantes, conversions douteuses, volume faible.

Prompt complet :

Réalise un audit Google Ads du compte 1234567890 sur les 30 derniers jours. Structure l’analyse en 10 parties : vue globale, campagnes actives, dépenses principales, conversions, CPA, campagnes sous-performantes, campagnes performantes, risques de tracking, questions à poser, priorités d’action. Utilise uniquement les données récupérées via le MCP Google Ads. Si une donnée manque, dis-le clairement.

Ce prompt est efficace parce qu’il demande à Claude d’être transparent sur les données manquantes.

Comment transformer l’analyse en plan d’action

Après l’audit, tu peux demander un plan d’action. Mais attention : comme le MCP officiel ne modifie rien, le plan d’action reste une recommandation.

Prompt :

À partir de l’audit précédent, transforme les constats en plan d’action sur 14 jours. Classe les actions par impact estimé et niveau de risque. Pour chaque action, indique les données qui justifient la recommandation et ce qu’il faut vérifier manuellement dans Google Ads avant d’appliquer.

Tu obtiens alors une roadmap utilisable :

• actions rapides ;
• vérifications tracking ;
• campagnes à surveiller ;
• budgets à revoir ;
• hypothèses à tester ;
• éléments à ne pas changer trop vite.

Cette étape est souvent plus utile que l’audit lui-même. Un bon audit donne une vision. Un bon plan d’action donne une séquence.

Peut-on créer des campagnes avec Claude malgré tout ?

Oui, mais pas avec le MCP officiel seul.

Pour créer des campagnes depuis Claude, il faut un serveur MCP qui expose des outils d’écriture. Ces outils doivent utiliser Google Ads API pour créer budgets, campagnes, ad groups, keywords et annonces.

Mais il faut être très prudent. Un MCP writer doit idéalement :

• créer les campagnes en PAUSED par défaut ;
• imposer un budget quotidien maximal ;
• faire un dry-run avant toute mutation ;
• demander une confirmation explicite ;
• journaliser toutes les actions ;
• bloquer les opérations destructives ;
• distinguer préparation et activation ;
• permettre une validation humaine avant publication.

Le workflow idéal ressemble à :

1. Claude analyse le compte avec le MCP officiel.
2. Claude propose une structure de campagne.
3. Un MCP writer prépare une création en brouillon ou en pause.
4. Tu relis la structure.
5. Tu valides manuellement.
6. La campagne reste en pause jusqu’à validation finale.

Il ne faut pas donner à une IA un accès direct et non limité à un compte publicitaire. Le risque n’est pas seulement technique. Il est financier.

Architecture recommandée en 2026

La meilleure architecture pour une utilisation sérieuse est hybride :

Claude Desktop
  ↓
MCP officiel Google Ads
  ↓
Analyse, reporting, diagnostic, GAQL
Claude Desktop
  ↓
MCP writer séparé
  ↓
Création contrôlée en PAUSED, avec validation humaine

Cette séparation protège ton compte. Le serveur officiel lit les données. Le serveur writer, s’il existe, agit uniquement dans un cadre limité.

Tu peux même décider que le writer ne soit pas connecté en permanence. Tu l’actives seulement quand tu veux préparer une campagne, puis tu le désactives ensuite. Pour une agence, c’est une pratique saine.

Exemple de workflow complet pour une agence

Imaginons une agence qui gère plusieurs comptes Google Ads.

Le matin, le consultant ouvre Claude Desktop et demande :

Liste tous les comptes Google Ads accessibles et signale ceux qui ont eu une forte variation de coût ou de conversions sur les 7 derniers jours.

Claude utilise le MCP officiel pour récupérer les comptes et les métriques. Ensuite, le consultant choisit un compte prioritaire :

Analyse le compte 1234567890. Je veux comprendre pourquoi le coût a augmenté cette semaine.

Claude regarde les campagnes, compare les périodes, identifie les variations, puis propose des hypothèses. Le consultant peut ensuite demander :

Prépare une note client de 300 mots expliquant la situation sans jargon technique.

À aucun moment Claude ne modifie le compte. Le consultant garde la main. Si une création de campagne est nécessaire, il utilise un workflow séparé avec validation.

Cette façon de travailler est réaliste et productive. Elle économise du temps sans abandonner le contrôle.

Exemple de workflow pour un entrepreneur solo

Un entrepreneur qui gère lui-même ses campagnes peut utiliser Claude comme assistant de diagnostic.

Chaque lundi, il demande :

Fais-moi le bilan Google Ads de la semaine dernière. Dis-moi si je dois m’inquiéter, quelles campagnes surveiller et quelles données regarder avant de toucher aux budgets.

Claude récupère les données via le MCP et produit une réponse lisible.

Le vendredi, il demande :

Compare cette semaine avec la précédente. Est-ce que mes campagnes lead gen progressent ou est-ce que je dépense plus pour le même résultat ?

L’entrepreneur n’a pas besoin d’être expert GAQL. Il garde son énergie sur les décisions business.

Exemple de workflow pour un consultant SEA

Un consultant SEA peut aller plus loin :

Pour le compte 1234567890, construis une analyse par campagne et par appareil sur les 30 derniers jours. Je veux voir si le mobile consomme trop de budget sans convertir. Si les données ne suffisent pas, indique les limites.

Puis :

Transforme cette analyse en recommandations, mais sépare les actions sûres, les hypothèses à tester et les décisions risquées.

Cette séparation est importante. Une IA peut repérer des signaux, mais elle ne sait pas toujours si une conversion est réellement qualifiée, si le tracking est fiable ou si une campagne a une raison stratégique d’exister.

Pourquoi le contexte business reste indispensable

Les données Google Ads ne racontent pas toute l’histoire.

Une campagne peut avoir un CPA plus élevé que les autres mais générer les meilleurs clients. Une autre peut avoir beaucoup de conversions mais surtout des leads faibles. Une troisième peut sembler inactive mais servir à protéger la marque. Une quatrième peut avoir un faible volume mais une valeur stratégique forte.

Claude peut analyser les données disponibles. Mais toi, tu dois apporter :

• la marge ;
• la qualité des leads ;
• le cycle de vente ;
• la saisonnalité ;
• les objectifs réels ;
• les contraintes commerciales ;
• les campagnes à préserver ;
• les tests en cours ;
• les changements récents de landing page ;
• les problèmes de tracking connus.

Le meilleur résultat vient de la combinaison :

données Google Ads + contexte business + raisonnement Claude + validation humaine

Sécurité : les règles à respecter

Même si le MCP officiel est read-only, il expose quand même des données sensibles à Claude. Tes campagnes, coûts, performances et comptes publicitaires sont des informations business.

Respecte ces règles :

• connecte uniquement les comptes nécessaires ;
• évite d’utiliser des credentials personnels partagés ;
• stocke les tokens dans un endroit sûr ;
• ne colle jamais ton developer token dans un document public ;
• ne mets pas tes credentials dans un dépôt Git ;
• supprime les anciens credentials inutilisés ;
• vérifie régulièrement les accès Google Ads ;
• limite les outils MCP actifs à ceux dont tu as besoin ;
• désactive les serveurs expérimentaux que tu n’utilises pas ;
• garde une trace des changements de configuration.

Si tu utilises Cloud Run, la sécurité devient encore plus importante. Un serveur exposé par URL doit être configuré correctement. L’URL ne doit pas devenir une porte ouverte vers tes données publicitaires.

Comment expliquer cette connexion à un client

Si tu es consultant ou agence, ton client peut s’inquiéter de voir “Claude connecté à Google Ads”. Il faut expliquer simplement.

Tu peux dire :

Nous utilisons une connexion officielle en lecture seule entre Claude et Google Ads. Elle permet d’analyser les performances plus rapidement, mais elle ne permet pas à Claude de modifier les campagnes, les budgets ou les annonces. Les décisions restent validées humainement.

Cette formulation rassure. Elle montre que l’IA sert à accélérer l’analyse, pas à remplacer la responsabilité.

Tu peux aussi préciser :

• les données restent limitées au compte connecté ;
• l’accès passe par Google Ads API ;
• le developer token et OAuth contrôlent les permissions ;
• les modifications restent manuelles ou séparées dans un workflow validé.

Checklist d’installation locale avec Claude Code

Avant de dire que ça ne marche pas, donne cette mission à Claude Code :

Fais-moi une vérification finale de mon installation Google Ads MCP pour Claude Desktop. Parcours la checklist point par point. Pour chaque point, indique : OK, à vérifier, ou manquant. Ne modifie rien sans me demander.

La checklist à parcourir est celle-ci :

• Claude Desktop est installé ;
• pipx est installé ;
• Google Ads API est activée dans Google Cloud ;
• tu as un Project ID Google Cloud ;
• tu as un developer token Google Ads ;
• le token a le bon niveau d’accès ;
• tu as créé des credentials OAuth ;
• tu as lancé gcloud auth application-default login avec le scope adwords ;
• tu as copié le bon chemin application_default_credentials.json ;
• tu as modifié claude_desktop_config.json ;
• le JSON est valide ;
• tu as ajouté GOOGLE_ADS_LOGIN_CUSTOMER_ID si tu passes par un MCC ;
• tu as redémarré Claude Desktop ;
• tu as testé avec “Quels comptes ai-je accès ?”.

Si tout est coché, la connexion a de bonnes chances de fonctionner.

Checklist d’utilisation après connexion

Une fois connecté, ne commence pas par des questions trop larges. Avance dans cet ordre :

1. lister les comptes accessibles ;
2. choisir un customer ID ;
3. lister les campagnes actives ;
4. récupérer les métriques sur une période courte ;
5. comparer les campagnes ;
6. demander un diagnostic ;
7. donner le contexte business ;
8. demander un plan d’action ;
9. vérifier les limites des données ;
10. appliquer les décisions manuellement dans Google Ads.

Cette progression évite les erreurs d’interprétation.

Exemple d’analyse complète à demander

Voici un prompt plus complet que tu peux utiliser quand tout fonctionne :

Utilise le MCP Google Ads pour analyser le compte 1234567890 sur les 30 derniers jours. Mon objectif est la génération de leads. Je veux une analyse structurée en 8 parties : résumé exécutif, dépenses globales, campagnes les plus coûteuses, campagnes avec conversions, campagnes sans conversions, signaux d’alerte, opportunités d’optimisation, prochaines actions recommandées. Pour chaque recommandation, indique la donnée qui la justifie. Si une information manque, ne l’invente pas.

Ce prompt force Claude à citer la base de ses recommandations. C’est essentiel pour éviter les réponses trop confiantes.

Exemple de prompt pour un reporting hebdomadaire

Prépare un reporting hebdomadaire Google Ads pour le compte 1234567890. Compare les 7 derniers jours avec les 7 jours précédents. Donne un résumé simple, puis un tableau avec coût, clics, impressions, conversions et CPA par campagne. Termine avec trois priorités pour la semaine prochaine.

Ce type de prompt est très utile pour les routines d’agence. Il transforme Claude en assistant de reporting.

Exemple de prompt pour trouver des anomalies

Cherche des anomalies dans les performances du compte 1234567890 sur les 14 derniers jours. Regarde les variations de coût, clics, impressions, conversions et CPA. Signale uniquement les variations qui méritent une vérification humaine. Pour chaque anomalie, propose une hypothèse et une vérification à faire dans Google Ads.

L’idée n’est pas de demander à Claude de tout corriger. L’idée est de lui demander de signaler ce qui mérite ton attention.

Exemple de prompt pour préparer une nouvelle campagne

Même si le MCP officiel ne crée pas de campagne, il peut aider à préparer la stratégie.

À partir des performances actuelles du compte 1234567890, propose une structure de nouvelle campagne Search pour générer des leads. Ne crée rien. Donne seulement : objectif, ciblage, groupes d’annonces, idées de mots-clés, exclusions à vérifier, messages publicitaires, landing page recommandée et risques à surveiller.

Ce prompt utilise les données existantes pour construire une recommandation. Ensuite, tu peux créer la campagne manuellement dans Google Ads ou utiliser un workflow writer contrôlé.

Comment garder un style d’analyse professionnel

Claude peut parfois être trop général ou trop enthousiaste. Pour obtenir une analyse professionnelle, impose un cadre :

• pas de promesses de performance ;
• pas de recommandation sans donnée ;
• distinction entre fait, hypothèse et action ;
• mention des limites ;
• langage clair ;
• priorisation ;
• prudence sur les petits volumes.

Prompt utile :

Réponds comme un consultant Google Ads senior. Sépare toujours les faits observés, les hypothèses et les actions recommandées. Ne recommande pas de changement si le volume de données est trop faible. Signale explicitement les limites de l’analyse.

Ce cadrage améliore fortement la qualité des réponses.

Pourquoi le MCP officiel est une bonne première étape

Même s’il ne crée pas de campagnes, le MCP officiel Google Ads est probablement la meilleure première brique pour connecter Claude à Google Ads.

Il est officiel, open source, orienté lecture, conçu pour l’API Google Ads, et documenté. Il évite de confier tout de suite des droits d’écriture à un serveur communautaire. Il permet de valider ton besoin réel : est-ce que Claude t’aide déjà à gagner du temps en analyse ?

Dans beaucoup de cas, la réponse sera oui.

Une grande partie du travail Google Ads n’est pas la modification elle-même. C’est :

• comprendre ce qui se passe ;
• trouver où regarder ;
• prioriser ;
• expliquer les chiffres ;
• préparer des recommandations ;
• produire des reportings ;
• construire des hypothèses.

Le MCP officiel aide précisément sur ces tâches.

Quand passer à un MCP writer

Tu peux envisager un MCP writer si tu as déjà :

• une connexion read-only stable ;
• une bonne compréhension de Google Ads API ;
• des règles internes de validation ;
• un budget cap ;
• une procédure de review ;
• un compte test ;
• une stratégie claire de rollback ;
• une personne responsable des validations.

Ne commence pas par là.

Le bon ordre est :

1. lecture officielle ;
2. analyse fiable ;
3. prompts solides ;
4. workflows de reporting ;
5. préparation de plans ;
6. seulement ensuite, écriture contrôlée.

Cette progression évite de construire une automatisation dangereuse avant d’avoir compris les usages utiles.

Configuration avancée : limiter les outils disponibles

Le repo officiel permet aussi de configurer les outils via tools_config.yaml. Cela sert à activer ou désactiver certains outils ou à personnaliser les namespaces.

Pour la plupart des utilisateurs, ce n’est pas nécessaire au départ. Le serveur fonctionne avec une configuration par défaut. Mais dans un contexte d’équipe, c’est intéressant.

Par exemple, tu peux décider de n’exposer que certains outils, ou de renommer les préfixes pour rendre l’usage plus clair. Cette configuration est plus avancée, mais elle montre que le MCP officiel est pensé pour être contrôlé.

Si tu débutes, ignore cette partie. Fais d’abord fonctionner la connexion standard.

Configuration avancée : utiliser un google-ads.yaml

Le repo officiel mentionne aussi une méthode avec la librairie Python Google Ads et un fichier google-ads.yaml. Si tu as déjà une configuration Google Ads API Python qui fonctionne, tu peux la réutiliser.

Cette méthode est plus adaptée aux développeurs ou aux équipes qui utilisent déjà Google Ads API dans leurs scripts.

Pour un utilisateur Claude Desktop classique, la méthode ADC reste souvent plus simple :

• credentials OAuth ;
• commande gcloud auth application-default login ;
• chemin vers application_default_credentials.json ;
• variables dans Claude Desktop.

Comment savoir si l’analyse est basée sur les données réelles

Quand Claude utilise un MCP, il peut parfois mélanger données réelles et raisonnement général. Pour éviter cela, demande-lui d’être explicite.

Prompt :

Dans ta réponse, sépare les données récupérées via le MCP, les calculs que tu fais à partir de ces données, et les hypothèses marketing. Si tu n’as pas récupéré une donnée via le MCP, indique-le.

Ce prompt est très utile pour garder de la rigueur.

Tu peux aussi demander :

Donne-moi la requête ou les champs que tu as utilisés pour récupérer ces données.

Cela te permet de vérifier la logique d’analyse.

Les limites des données Google Ads

Même avec une bonne connexion, certaines limites restent.

Les données peuvent être retardées. Certaines conversions peuvent arriver plus tard. Le tracking peut être mal configuré. Les conversions importées depuis un CRM peuvent ne pas être disponibles immédiatement. Les petits volumes peuvent rendre les conclusions fragiles. Les campagnes récentes peuvent manquer d’historique.

Claude doit donc être prudent.

Un bon audit doit dire :

• “la donnée montre ceci” ;
• “cela peut signifier cela” ;
• “il faut vérifier ceci avant d’agir”.

Une mauvaise analyse dit :

• “coupez cette campagne immédiatement” ;
• “augmentez ce budget” ;
• “cette campagne est mauvaise” ;
• sans vérifier le contexte.

Avec Google Ads, la nuance est essentielle.

Cas pratique : premier jour après installation

Voici ce que tu peux faire le premier jour.

D’abord, vérifie la connexion :

Liste les comptes accessibles via Google Ads MCP.

Ensuite, choisis le compte :

Utilise le compte 1234567890 pour les prochaines analyses.

Puis demande une vue simple :

Liste les campagnes actives sur les 30 derniers jours avec coût, clics, impressions et conversions.

Ensuite, ajoute le contexte :

Mon objectif est de générer des demandes de devis. Le CPA cible est de 40 euros. Analyse les campagnes par rapport à cet objectif.

Enfin, demande une synthèse :

Résume les trois décisions les plus importantes à prendre cette semaine, mais indique ce qui doit être vérifié manuellement avant toute modification.

Ce workflow suffit déjà à gagner du temps.

Cas pratique : audit mensuel

Pour un audit mensuel, utilise une structure plus complète.

Prompt :

Fais un audit mensuel du compte 1234567890. Analyse les 30 derniers jours et compare si possible avec les 30 jours précédents. Je veux : résumé exécutif, évolution globale, top campagnes par dépense, top campagnes par conversions, campagnes sans conversions, risques de tracking, hypothèses, recommandations priorisées et questions à poser au client.

Ensuite :

Transforme cet audit en email client clair et professionnel. Ne mets pas de jargon technique. Explique les points importants, les décisions proposées et les prochaines étapes.

Claude devient alors un assistant d’analyse et de communication.

Cas pratique : préparation d’un call client

Avant un call client, demande :

Prépare une note de réunion pour le compte 1234567890. Je veux comprendre ce qui a changé depuis la dernière période, quels points expliquer au client, quelles questions poser, et quelles décisions ne pas prendre sans données supplémentaires.

Ce prompt est utile parce qu’il ne se limite pas au reporting. Il prépare aussi la discussion.

Cas pratique : recherche de problèmes de tracking

Le MCP officiel ne vérifie pas tout ton tracking, mais il peut signaler des symptômes.

Prompt :

Analyse les conversions du compte 1234567890 sur les 30 derniers jours. Cherche des signes possibles de problème de tracking : chute brutale, volume incohérent, campagnes avec beaucoup de clics mais zéro conversion, variations anormales. Ne conclus pas trop vite : liste les vérifications à faire.

Ce type d’analyse peut faire gagner beaucoup de temps avant d’aller dans Google Tag Manager, GA4 ou le CRM.

Cas pratique : analyse pour réduire le budget gaspillé

Prompt :

Je veux réduire le budget gaspillé sans casser les campagnes qui fonctionnent. Analyse le compte 1234567890 sur les 30 derniers jours. Identifie les campagnes à surveiller, celles où une réduction peut être envisagée, et celles qu’il ne faut pas toucher sans analyse plus fine. Justifie chaque recommandation avec les données.

Cette formulation est meilleure que “quelles campagnes couper ?”. Elle force Claude à être prudent.

Cas pratique : recherche d’opportunités de scaling

Prompt :

Cherche les campagnes qui pourraient supporter plus de budget. Utilise les données du compte 1234567890 sur les 30 derniers jours. Je veux uniquement les campagnes avec signaux positifs : conversions, CPA acceptable, volume suffisant. Indique aussi les risques avant augmentation.

Une bonne analyse de scaling ne dit pas seulement “augmentez le budget”. Elle regarde la stabilité, le volume et le risque.

Comment organiser tes conversations Claude

Pour éviter le désordre, crée des conversations séparées :

• une conversation pour la configuration MCP ;
• une conversation pour les audits hebdomadaires ;
• une conversation par compte client important ;
• une conversation pour les prompts et templates ;
• une conversation pour la stratégie de création de campagnes.

Dans chaque conversation, rappelle le contexte :

• customer ID ;
• objectif ;
• période ;
• type de conversions ;
• contraintes.

Claude peut mieux travailler quand le cadre reste stable.

Comment documenter ton installation

Une fois la connexion faite, crée une petite documentation interne. Elle doit contenir :

• le nom du serveur MCP ;
• l’emplacement du fichier Claude Desktop ;
• les variables utilisées, sans afficher les secrets ;
• la méthode d’authentification ;
• le compte Google utilisé ;
• le niveau du developer token ;
• la procédure de redémarrage ;
• les prompts de test ;
• les erreurs connues.

Ne mets jamais le developer token ou les credentials complets dans une documentation partagée.

Tu peux écrire :

GOOGLE_ADS_DEVELOPER_TOKEN = stocké localement dans claude_desktop_config.json
GOOGLE_APPLICATION_CREDENTIALS = chemin local vers ADC

Mais évite de publier les valeurs.

Le bon niveau d’automatisation

L’automatisation idéale n’est pas forcément l’automatisation maximale.

Pour Google Ads, le bon niveau est souvent :

• automatiser la collecte ;
• automatiser la mise en forme ;
• automatiser le diagnostic initial ;
• automatiser les questions à poser ;
• garder les décisions sensibles sous contrôle humain.

Claude peut accélérer la réflexion. Il ne doit pas devenir un bouton magique qui dépense de l’argent sans validation.

Cette philosophie est particulièrement importante en 2026, avec la montée des agents IA. Plus les agents deviennent capables, plus les garde-fous deviennent essentiels.

Résumé opérationnel

Pour connecter Google Ads à Claude Desktop en 2026 avec le MCP officiel, retiens ceci :

• le MCP officiel Google Ads est un serveur read-only ;
• il permet à Claude de lire et analyser les données Google Ads ;
• il ne crée pas de campagnes ;
• la méthode locale utilise pipx et claude_desktop_config.json ;
• la méthode distante utilise une URL httpUrl, mais seulement après déploiement du MCP ;
• il faut un projet Google Cloud, Google Ads API activée, un developer token et des credentials OAuth ;
• le scope OAuth important est https://www.googleapis.com/auth/adwords ;
• si tu passes par un MCC, ajoute GOOGLE_ADS_LOGIN_CUSTOMER_ID ;
• commence toujours par lister les comptes accessibles ;
• donne à Claude le contexte business pour obtenir de vraies recommandations ;
• garde les modifications de campagnes pour un workflow séparé et contrôlé.

FAQ rapide

Est-ce que Claude peut voir toutes mes données Google Ads ?

Claude ne voit que ce que le serveur MCP peut récupérer avec les credentials configurés. Si l’utilisateur authentifié n’a accès qu’à un seul compte Google Ads, Claude ne pourra pas lire les autres. Si l’accès passe par un manager account, il faut configurer correctement GOOGLE_ADS_LOGIN_CUSTOMER_ID. La bonne pratique consiste à tester avec une demande simple, comme la liste des comptes accessibles, avant de lancer un audit complet.

Est-ce que cette connexion remplace Google Ads ?

Non. Claude ne remplace pas l’interface Google Ads. Il sert à comprendre plus vite, résumer, comparer, diagnostiquer et préparer des décisions. L’interface Google Ads reste nécessaire pour vérifier certains détails, lire les recommandations natives, inspecter les assets, contrôler le tracking et appliquer les changements si tu utilises uniquement le MCP officiel.

Est-ce que je dois être développeur pour l’installer ?

Pas forcément, mais il faut être à l’aise avec quelques étapes techniques : installer pipx, créer un projet Google Cloud, activer Google Ads API, générer des credentials OAuth et modifier un fichier JSON. Si tu suis les étapes dans l’ordre, la partie la plus délicate n’est pas Claude Desktop, mais l’authentification Google.

Est-ce que je peux connecter plusieurs comptes ?

Oui, si ton utilisateur Google ou ton manager account a accès à plusieurs comptes. Le serveur peut lister les customers accessibles, puis tu peux demander à Claude d’analyser un customer ID précis. Pour une agence, c’est justement un des usages les plus intéressants : passer d’un compte à l’autre sans reconstruire manuellement les exports.

Est-ce que je peux utiliser cette connexion pour mes reportings clients ?

Oui. C’est même l’un des meilleurs cas d’usage. Tu peux demander à Claude de produire un résumé hebdomadaire ou mensuel à partir des données réelles. Pour un rendu professionnel, donne toujours la période, le compte, le niveau de détail, le ton souhaité et les métriques prioritaires. Ajoute aussi une consigne simple : ne pas inventer les données manquantes.

Quelle est la meilleure première demande à faire après installation ?

La meilleure première demande est :

Liste les comptes Google Ads accessibles via le MCP Google Ads, puis demande-moi quel customer ID je veux analyser.

Cette demande vérifie la connexion sans lancer d’analyse complexe. Si elle fonctionne, tu peux passer aux campagnes, puis aux métriques.

Conclusion

Connecter Google Ads à Claude n’est plus une idée futuriste. Avec le MCP officiel Google Ads, tu peux déjà transformer Claude Desktop en assistant d’analyse publicitaire. Il peut lire les comptes accessibles, interroger les campagnes, comprendre les ressources Google Ads API et produire des diagnostics beaucoup plus rapides qu’un reporting manuel.

La clé est de bien comprendre la limite : l’officiel lit, il n’écrit pas. Cette limite protège ton compte et ton budget. Pour beaucoup d’usages, c’est déjà largement suffisant : audits, reportings, préparation de réunions, recherche d’anomalies, analyse de performance, construction de requêtes GAQL et priorisation des actions.

La meilleure façon de commencer est simple : ouvre Claude Code, demande-lui de vérifier ton environnement, fais-lui préparer la configuration, ajoute toi-même les valeurs sensibles, puis redémarre Claude Desktop et teste la liste des comptes. Tu n’as pas besoin de tout comprendre avant de commencer. Tu as surtout besoin d’avancer dans le bon ordre, avec un assistant qui t’aide à ne pas te perdre.

Une fois que ce socle est fiable, tu peux envisager une architecture distante ou un MCP writer séparé, mais seulement avec des garde-fous sérieux.

En pratique, le plus grand gain ne vient pas du fait que Claude “contrôle” Google Ads. Le vrai gain vient du fait que Claude peut comprendre tes données plus vite, t’aider à poser les bonnes questions et transformer un compte publicitaire complexe en décisions lisibles.

Sources utiles

• Google Ads MCP server, guide développeur officiel
• Repo officiel Google Ads MCP
• Documentation MCP pour Claude Desktop et serveurs locaux
• Google Ads API developer token
• Google Ads API OAuth
• Google Ads API, démarrage
• Google Ads API, requêtes GAQL
• Google Ads API, référence des champs, métriques et segments
• Google Ads API release notes
• Annonce officielle “Open Source Google Ads API MCP Server”