Claude Code pour Google Ads : piloter ses comptes

Claude Code est l'outil en ligne de commande d'Anthropic. Il travaille depuis un dossier, lit et écrit des fichiers, appelle des serveurs MCP et se pilote par règles de permission. Branché au serveur MCP officiel de Google Ads, il devient un poste d'analyse de comptes : les données arrivent par GAQL, les résultats atterrissent dans des fichiers que vous gardez, et le dossier du client porte ses propres consignes. Ce guide décrit l'organisation d'un dossier par client, la commande de branchement, les garde-fous, une première série de demandes et le lancement sans interface avec claude -p.

Les faits cités viennent de la documentation de Google Ads API et de celle de Claude Code, consultées le 6 octobre 2026. Le serveur est décrit par Google comme étant en lecture seule dans sa version actuelle. Pour la configuration dans Claude Desktop et les prérequis (ce guide date d'avant le 9 septembre 2026 et mentionne encore un jeton développeur), voir notre guide de setup du MCP Google Ads.

Ce que le terminal change

Une conversation dans une application de chat s'arrête avec la fenêtre. Claude Code démarre chaque session avec un contexte vierge, et deux mécanismes portent la mémoire d'une session à l'autre, selon sa documentation sur la mémoire: les fichiers CLAUDE.md, que vous écrivez, et la mémoire automatique, que Claude rédige lui-même d'après vos corrections. Claude Code charge les CLAUDE.md du dossier courant et de tous ses dossiers parents, du plus large au plus proche, et les concatène.

Cette règle de chargement suggère une organisation d'agence : un dossier racine avec les règles communes, un sous-dossier par client avec son propre CLAUDE.md, et un dossier de rapports dans chacun.

agence/
  CLAUDE.md              règles communes (format des rapports, langue, garde-fous)
  client-a/
    CLAUDE.md            identifiant du compte, objectifs, marges, saisonnalité
    rapports/            exports et analyses datés
  client-b/
    CLAUDE.md
    rapports/

Lancer claude dans client-a/ charge les règles de l'agence puis celles du client. Un point à garder en tête, que la documentation formule sans détour : Claude traite ces fichiers comme du contexte, pas comme une configuration appliquée de force. Pour interdire une action quoi que Claude décide, il faut une règle de permission ou un hook, décrits plus bas.

Brancher le serveur Google Ads officiel

La page du serveur MCP Google Ads donne ses caractéristiques : protocole MCP, mode lecture seule dans la version actuelle, Python, transport par entrée et sortie standard (stdio) ou HTTP et SSE avec un déploiement sur Cloud Run, authentification par OAuth 2.0 ou compte de service. Elle liste trois outils.

Google précise que cette implémentation est strictement en lecture seule : elle ne peut ni modifier des enchères, ni mettre des campagnes en pause, ni créer de nouveaux assets.

Les prérequis

D'après la page de Google, il faut l'identifiant d'un projet Google Cloud (GOOGLE_PROJECT_ID) dont le niveau d'accès à l'API est Explorer, Basic ou Standard, ainsi que des identifiants OAuth : soit un couple identifiant client et secret client, soit des identifiants par défaut de l'application (ADC) obtenus avec gcloud auth application-default login. Pour passer par un compte administrateur, la variable GOOGLE_ADS_LOGIN_CUSTOMER_ID est prévue. La page ajoute que les jetons développeur ont été arrêtés le 9 septembre 2026 et ne sont plus requis dans la dernière version du serveur, puisque les niveaux d'accès sont associés au projet Cloud. Un tutoriel qui date d'avant ce changement peut donc encore en demander un.

La commande pour Claude Code

Google donne une configuration JSON qui lance le serveur avec pipx run à partir de son dépôt GitHub. La documentation de Claude Code décrit la syntaxe d'ajout d'un serveur local : les options de Claude, puis --, puis la commande du serveur. Les deux assemblés :

claude mcp add --env GOOGLE_PROJECT_ID=votre-projet-cloud \
  --env GOOGLE_APPLICATION_CREDENTIALS=/chemin/vers/credentials.json \
  --transport stdio google-ads \
  -- pipx run --spec git+https://github.com/googleads/google-ads-mcp.git google-ads-mcp

Le nom donné ici, google-ads, sert ensuite dans les règles de permission. La documentation de Claude Code précise que la portée par défaut est locale : la configuration reste privée, limitée au projet courant, dans ~/.claude.json, ce qui convient aux serveurs dont les identifiants ne doivent pas figurer dans un dépôt. Cette commande est notre assemblage de deux pages : Google ne publie pas de ligne claude mcp addpour ce serveur.

Dans une session, /mcp liste les serveurs connectés et leur état. Une première demande de contrôle suffit : « Quels comptes Google Ads puis-je interroger ? »

Les garde-fous

Le serveur ne peut pas écrire dans Google Ads, mais Claude Code, lui, sait écrire des fichiers et lancer des commandes. Trois niveaux de protection se superposent, d'après la documentation des permissions.

Pour un poste d'analyse, nous partirions d'un fichier .claude/settings.json qui autorise explicitement les trois outils de lecture, afin de ne pas être interrompu à chaque requête, et laisse le reste au mode par défaut :

{
  "permissions": {
    "allow": [
      "mcp__google-ads__list_accessible_customers",
      "mcp__google-ads__search",
      "mcp__google-ads__get_resource_metadata"
    ]
  }
}

Les écritures de fichiers et la plupart des commandes shell continuent alors de demander une approbation. Si vous ajoutez plus tard un second serveur capable d'écrire dans un compte publicitaire, une règle deny nommant ses outils d'écriture reste prioritaire sur toute règle allow, quel que soit le fichier de paramètres où elle se trouve, d'après la même documentation.

Un premier tour de compte

Le serveur parle GAQL. Google en donne la structure dans son aperçu du langage de requête : on sélectionne des attributs et des métriques, on ajoute des segments comme la date, on filtre avec WHERE. Une requête de pilotage hebdomadaire, écrite avec des champs de la documentation :

SELECT
  campaign.name,
  campaign.status,
  metrics.impressions,
  metrics.clicks,
  metrics.cost_micros,
  metrics.conversions,
  metrics.conversions_value
FROM campaign
WHERE segments.date DURING LAST_7_DAYS
  AND metrics.impressions > 0
ORDER BY metrics.cost_micros DESC
LIMIT 20

Deux points de lecture. LAST_7_DAYS désigne les sept derniers jours sans compter aujourd'hui, selon la page des plages de dates de Google. Et les montants monétaires de l'API sont en micros : la documentation des champs précise qu'un million de micros équivaut à une unité de devise, donc un cost_micros de 12 500 000 correspond à 12,50 dans la devise du compte. Demandez à Claude de convertir, et vérifiez la première conversion à la main.

Google recommande de ne sélectionner que les champs utiles, d'utiliser LIMIT pendant les tests et de filtrer dans WHERE. Ces conseils valent aussi pour la fenêtre de contexte : Claude Code affiche un avertissement quand la sortie d'un outil MCP dépasse 10 000 jetons et plafonne par défaut à 25 000.

Une séquence de départ, à lancer depuis le dossier du client :

1. « Liste les comptes accessibles et confirme l'identifiant du client dans CLAUDE.md. »
2. « Montre-moi les champs interrogeables de la ressource campaign. » (get_resource_metadata)
3. « Sors les 20 campagnes les plus dépensières des sept derniers jours, avec clics, conversions et valeur de conversion. »
4. « Écris ce tableau dans rapports/2026-10-09-campagnes.md, avec le coût converti en euros. »
5. « Compare aux sept jours précédents et liste les campagnes dont la valeur de conversion baisse alors que le coût monte. »
6. « Rédige les actions à valider, sans rien exécuter. »

La dernière demande compte : le serveur est en lecture seule, donc toute modification passe par un autre outil, par exemple l'interface de Google Ads. Le terminal produit la liste des changements à décider, pas leur exécution. La lecture business reste la vôtre, et nos articles sur le workflow d'analyse et sur le reporting automatisé détaillent ce qu'on peut déléguer et ce qu'on garde.

Ce que le CLAUDE.md du client doit contenir

Le fichier remplace la ré-explication de début de session. Un squelette à adapter, avec les informations que Claude ne peut pas deviner depuis le compte :

# Client A (e-commerce)

Compte Google Ads : 1234567890 (via le compte administrateur 0987654321)
Objectif : ROAS cible de 4, marge brute moyenne de 38 %
Saisonnalité : pic en novembre, creux en janvier

Règles de travail
- Lecture seule : ne propose jamais d'exécuter une modification, liste les actions à valider.
- Convertis les montants en euros avant tout tableau.
- Écris chaque analyse dans rapports/ avec la date dans le nom du fichier.
- Si une requête renvoie plus de 50 lignes, agrège avant d'afficher.

Les chiffres ci-dessus sont des placeholders. La documentation de Claude Code recommande de garder dans ce fichier les faits que Claude doit connaître à chaque session et de déplacer les procédures longues vers des skills ou des règles propres à un chemin.

Lancer une analyse sans interface

L'option -p exécute Claude Code en mode non interactif, ce qui permet de l'appeler depuis un script. Les options --allowedTools (outils approuvés sans invite) et --max-budget-usd (plafond de dépense, en mode-p uniquement) encadrent le lancement :

cd client-a
claude -p "Sors les 20 campagnes les plus dépensières des 7 derniers jours et écris l'analyse dans rapports/hebdo.md" \
  --allowedTools "mcp__google-ads__search" "Write" \
  --max-budget-usd 2

Trois précisions tirées de la documentation. Sans --bare, une session claude -p charge les mêmes hooks, CLAUDE.md et serveurs MCP qu'une session interactive. Il n'y a pas de panneau /mcp en mode non interactif : un serveur qui exigerait une connexion OAuth doit être autorisé auparavant depuis une session interactive, avec /mcp ou claude mcp login. Enfin, le plafond de dépense s'appuie sur une estimation côté client, qui peut différer de la facture. Pour une exécution récurrente, planifiez-la avec l'outil de planification de votre système.

Les limites à connaître

• Le serveur officiel lit, il ne modifie rien : les changements se font par un autre outil, par exemple l'interface de Google Ads.
• Dans la configuration stdio décrite ici, il tourne en local sur votre poste avec vos identifiants Google : réservez-le à un poste de confiance et ne versionnez jamais le fichier d'identifiants.
• Les résultats sont lus par un modèle : une conversion de micros, un filtre de date ou un pourcentage se vérifient une première fois dans l'interface.
• Le serveur expose les données du compte à Claude : vérifiez ce que votre contrat avec le client autorise avant de brancher un compte.
• La documentation de Claude Code rappelle que les serveurs qui récupèrent du contenu externe exposent à l'injection de prompt : ne branchez que des serveurs dont vous maîtrisez la source.

Par où commencer

1. Créer le dossier du client, son CLAUDE.md et le dossier rapports/.
2. Préparer le projet Cloud et les identifiants OAuth, puis ajouter le serveur avec la commande ci-dessus.
3. Poser le fichier .claude/settings.json avec les trois outils autorisés.
4. Dérouler la séquence de six demandes et comparer chaque chiffre à l'interface.
5. N'automatiser avec claude -p qu'une analyse que vous avez déjà validée trois fois à la main.

Questions fréquentes sur Claude Code et Google Ads

Sources consultées le 6 octobre 2026

• Google : serveur MCP Google Ads, aperçu de GAQL, plages de dates prédéfinies, champs de métriques, champs de budget (micros)
• Anthropic : MCP dans Claude Code, permissions, mémoire et CLAUDE.md, exécution non interactive, référence de la ligne de commande