Rapports SEO sur mesure avec Claude Code et Search Console

Les rapports SEO pour stakeholders sont un gouffre de temps. Exporter les CSV depuis Search Console, pivoter dans Google Sheets, copier-coller dans Slides, recommencer chaque semaine. Avec Claude Code connecté directement à l'API GSC, vous pouvez construire un pipeline qui génère un rapport HTML complet — visualisations incluses — en une seule commande.

Pourquoi Looker Studio ne suffit plus

Looker Studio (ex Data Studio) reste l'outil par défaut pour visualiser les données GSC. Le problème : il impose un cadre rigide. Vous voulez croiser les données de positionnement avec un export Screaming Frog pour identifier les pages qui perdent des positions ET qui ont des problèmes techniques ? Bonne chance avec un connecteur natif.

Les limites concrètes qui justifient de passer à un pipeline programmatique :

• Pas de logique conditionnelle : impossible de générer un commentaire automatique du type "La catégorie /chaussures-running/ a perdu 23% de clics WoW, probablement lié au déréférencement de 47 URLs détecté le 12 mai".
• Pas de croisement avec des sources externes : données Screaming Frog, logs serveur, exports Ahrefs, données de monitoring Seogard — tout ça reste cloisonné.
• Pas de personnalisation par audience : votre VP Marketing ne veut pas le même rapport que votre Lead Dev. Looker Studio vous force à maintenir N dashboards.

Claude Code change la donne parce qu'il peut exécuter du code Python ou TypeScript, appeler des APIs, manipuler des fichiers, et produire un output structuré — le tout dans une boucle conversationnelle où vous affinez le résultat itérativement.

Connecter l'API Google Search Console

Créer les credentials OAuth 2.0

L'API GSC utilise OAuth 2.0. Pas de clé API simple. Vous devez passer par la Google Cloud Console pour créer un client OAuth de type "Desktop application".

# 1. Activer l'API Search Console dans votre projet GCP
gcloud services enable searchconsole.googleapis.com

# 2. Créer le client OAuth (ou le faire via l'interface Cloud Console)
# Télécharger le fichier client_secret.json

# 3. Installer les dépendances Python
pip install google-auth-oauthlib google-api-python-client pandas matplotlib

Le script d'authentification et de récupération

Voici le script Python complet que Claude Code peut exécuter. L'astuce : structurer la réponse de l'API en DataFrame pandas dès le départ, ce qui facilite toutes les manipulations ultérieures.

import os
import json
import pandas as pd
from datetime import datetime, timedelta
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

SCOPES = ['https://www.googleapis.com/auth/webmasters.readonly']
PROPERTY = 'sc-domain:votresite.fr'  # ou 'https://www.votresite.fr/'

def get_gsc_service():
    """Authentification OAuth avec cache du token."""
    creds = None
    if os.path.exists('token.json'):
        creds = Credentials.from_authorized_user_file('token.json', SCOPES)
    if not creds or not creds.valid:
        flow = InstalledAppFlow.from_client_secrets_file('client_secret.json', SCOPES)
        creds = flow.run_local_server(port=0)
        with open('token.json', 'w') as token:
            token.write(creds.to_json())
    return build('searchconsole', 'v1', credentials=creds)

def fetch_gsc_data(service, start_date, end_date, dimensions=['query', 'page'], row_limit=25000):
    """Récupère les données GSC avec pagination automatique."""
    all_rows = []
    start_row = 0
    
    while True:
        request = {
            'startDate': start_date,
            'endDate': end_date,
            'dimensions': dimensions,
            'rowLimit': row_limit,
            'startRow': start_row,
            'dataState': 'final'  # Exclure les données partielles
        }
        response = service.searchanalytics().query(
            siteUrl=PROPERTY, body=request
        ).execute()
        
        rows = response.get('rows', [])
        if not rows:
            break
            
        for row in rows:
            data = {}
            for i, dim in enumerate(dimensions):
                data[dim] = row['keys'][i]
            data['clicks'] = row['clicks']
            data['impressions'] = row['impressions']
            data['ctr'] = row['ctr']
            data['position'] = row['position']
            all_rows.append(data)
        
        start_row += row_limit
        if len(rows) < row_limit:
            break
    
    return pd.DataFrame(all_rows)

# Période : 28 derniers jours vs 28 jours précédents
today = datetime.now().date()
end_current = today - timedelta(days=3)  # Données GSC = 3 jours de latence
start_current = end_current - timedelta(days=27)
end_previous = start_current - timedelta(days=1)
start_previous = end_previous - timedelta(days=27)

service = get_gsc_service()
df_current = fetch_gsc_data(service, str(start_current), str(end_current))
df_previous = fetch_gsc_data(service, str(start_previous), str(end_previous))

print(f"Période actuelle : {len(df_current)} lignes")
print(f"Période précédente : {len(df_previous)} lignes")

Point important sur la pagination : l'API GSC retourne un maximum de 25 000 lignes par requête. Pour un e-commerce de 15 000 pages avec un catalogue diversifié, vous atteindrez facilement 50 000+ combinaisons query/page. La boucle while ci-dessus gère ça automatiquement, mais gardez en tête que chaque appel consomme du quota API (1 200 requêtes/minute selon la documentation officielle).

Le piège du dataState

Le paramètre dataState: 'final' est crucial. Sans lui, vous récupérez les données "fraîches" des dernières 48-72 heures, qui sont incomplètes et fluctuantes. Les rapports basés sur des données partielles génèrent des faux positifs ("on a perdu 40% de clics hier !" — non, les données ne sont simplement pas consolidées). C'est le genre de détail qui différencie un rapport fiable d'un artefact anxiogène.

Construire les analyses automatisées avec Claude Code

Une fois les données en DataFrame, vous entrez dans le territoire où Claude Code brille. Au lieu d'écrire vous-même les fonctions d'analyse, vous demandez à Claude Code de les générer en décrivant le résultat attendu.

Le prompt engineering pour des analyses SEO précises

La qualité du rapport dépend entièrement de la précision de vos instructions. Voici un exemple de prompt structuré à passer à Claude Code après l'exécution du script de récupération :

Analyse les DataFrames df_current et df_previous.
Génère les analyses suivantes :

1. TOP MOVERS : les 20 pages avec la plus grande variation absolue de clics (positif et négatif), avec le delta de position moyenne associé.

2. CANNIBALISATION : identifie les queries pour lesquelles plus de 3 pages différentes reçoivent des impressions, avec un CTR moyen < 2%. Trie par impressions décroissantes.

3. OPPORTUNITÉS QUICK WIN : pages positionnées entre 5 et 15 en moyenne, avec plus de 500 impressions sur la période, et un CTR inférieur à la moyenne de leur tranche de position. Ce sont les pages qui underperforment par rapport à leur visibilité.

4. ANALYSE PAR RÉPERTOIRE : agrège clics, impressions, CTR moyen et position moyenne par premier niveau de répertoire URL (ex: /category/, /blog/, /product/). Compare WoW.

Output : un dictionnaire Python avec les 4 DataFrames résultants, nommés top_movers, cannibalization, quick_wins, directory_analysis.

Claude Code génère et exécute le code correspondant. Le résultat est un ensemble de DataFrames prêts à être transformés en visualisations ou en HTML.

Scénario concret : e-commerce de 12 000 pages

Prenons le cas d'un site e-commerce spécialisé en équipement outdoor — 12 000 pages indexées, 3 200 pages de produits actifs, 180 pages de catégories, un blog de 400 articles. L'équipe SEO de 2 personnes passe chaque lundi matin à préparer un rapport hebdomadaire pour le comité de direction.

Avec le pipeline Claude Code + GSC, voici ce qui change :

Avant : 3 heures de travail manuel. Export GSC → Google Sheets → nettoyage → tableaux croisés dynamiques → copier dans Slides → rédaction des commentaires. Le rapport est livré mardi.

Après : 15 minutes. Exécution du script → Claude Code analyse les données et génère les commentaires → rapport HTML exporté en PDF. Le rapport est prêt lundi à 9h15.

Sur cette volumétrie, l'API GSC retourne environ 85 000 lignes de données (query × page) sur 28 jours. Le script de récupération fait 4 appels API, terminés en moins de 10 secondes. L'analyse par Claude Code prend environ 30 secondes.

L'analyse par répertoire révèle par exemple que le répertoire /randonnee/ a perdu 18% de clics WoW, corrélé avec une dégradation de position moyenne de 4.2 → 5.8. L'analyse top_movers identifie que 6 des 10 pages les plus impactées sont des fiches produit qui ont perdu leur FAQ structured data suite au retrait des résultats enrichis FAQ par Google. Ce type de corrélation automatisée est impossible dans Looker Studio.

Générer des visualisations custom

Les graphiques Matplotlib/Seaborn conviennent pour des rapports internes. Pour des rapports stakeholders, vous avez besoin de quelque chose de plus propre. Deux approches.

Approche 1 : Matplotlib avec style custom

import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
import numpy as np

def plot_directory_comparison(directory_analysis):
    """Graphique de comparaison WoW par répertoire."""
    fig, axes = plt.subplots(1, 2, figsize=(16, 8))
    fig.suptitle('Performance par répertoire — Semaine du 12 au 18 mai 2026', 
                 fontsize=14, fontweight='bold', y=1.02)
    
    df = directory_analysis.sort_values('clicks_current', ascending=True).tail(15)
    
    # Graphique barres horizontales : clics current vs previous
    y_pos = np.arange(len(df))
    axes[0].barh(y_pos - 0.2, df['clicks_previous'], 0.4, 
                 label='S-1', color='#94a3b8', alpha=0.8)
    axes[0].barh(y_pos + 0.2, df['clicks_current'], 0.4, 
                 label='S en cours', color='#3b82f6', alpha=0.8)
    axes[0].set_yticks(y_pos)
    axes[0].set_yticklabels(df['directory'], fontsize=10)
    axes[0].set_xlabel('Clics')
    axes[0].set_title('Clics par répertoire')
    axes[0].legend()
    axes[0].xaxis.set_major_formatter(mticker.FuncFormatter(lambda x, _: f'{int(x):,}'))
    
    # Graphique delta : variation en %
    colors = ['#ef4444' if x < 0 else '#22c55e' for x in df['clicks_delta_pct']]
    axes[1].barh(y_pos, df['clicks_delta_pct'], color=colors, alpha=0.8)
    axes[1].set_yticks(y_pos)
    axes[1].set_yticklabels(df['directory'], fontsize=10)
    axes[1].set_xlabel('Variation (%)')
    axes[1].set_title('Variation WoW')
    axes[1].axvline(x=0, color='#64748b', linewidth=0.8)
    
    for i, (val, dir_name) in enumerate(zip(df['clicks_delta_pct'], df['directory'])):
        axes[1].text(val + (1 if val >= 0 else -1), i, f'{val:+.1f}%', 
                     va='center', fontsize=9, fontweight='bold')
    
    plt.tight_layout()
    plt.savefig('directory_comparison.png', dpi=150, bbox_inches='tight')
    plt.close()
    
plot_directory_comparison(directory_analysis)

Approche 2 : rapport HTML complet avec Plotly

Pour un rapport interactif partageable par lien, Plotly génère des graphiques HTML autonomes. Claude Code peut assembler un rapport HTML complet avec les graphiques embedded :

import plotly.graph_objects as go
from plotly.subplots import make_subplots

def generate_html_report(top_movers, cannibalization, quick_wins, directory_analysis):
    """Génère un rapport HTML standalone avec graphiques Plotly intégrés."""
    
    # Graphique top movers
    tm = top_movers.head(20)
    fig_movers = go.Figure()
    fig_movers.add_trace(go.Bar(
        x=tm['page'].apply(lambda x: x.split('/')[-2] if x.endswith('/') else x.split('/')[-1]),
        y=tm['clicks_delta'],
        marker_color=['#ef4444' if v < 0 else '#22c55e' for v in tm['clicks_delta']],
        text=[f"{v:+d}" for v in tm['clicks_delta']],
        textposition='outside'
    ))
    fig_movers.update_layout(
        title='Top 20 pages — Variation de clics WoW',
        xaxis_tickangle=-45,
        height=500,
        template='plotly_white'
    )
    
    # Assembler le HTML
    report_html = f"""
    <!DOCTYPE html>
    <html lang="fr">
    <head>
        <meta charset="UTF-8">
        <title>Rapport SEO Hebdomadaire — Semaine 20</title>
        <script src="https://cdn.plot.ly/plotly-2.35.0.min.js"></script>
        <style>
            body {{ font-family: 'Inter', -apple-system, sans-serif; max-width: 1200px; margin: 0 auto; padding: 2rem; color: #1e293b; }}
            h1 {{ border-bottom: 3px solid #3b82f6; padding-bottom: 0.5rem; }}
            .metric-grid {{ display: grid; grid-template-columns: repeat(4, 1fr); gap: 1rem; margin: 2rem 0; }}
            .metric-card {{ background: #f8fafc; border-radius: 8px; padding: 1.5rem; text-align: center; }}
            .metric-value {{ font-size: 2rem; font-weight: 700; color: #1e293b; }}
            .metric-delta {{ font-size: 0.9rem; margin-top: 0.25rem; }}
            .metric-delta.positive {{ color: #22c55e; }}
            .metric-delta.negative {{ color: #ef4444; }}
            table {{ width: 100%; border-collapse: collapse; margin: 1rem 0; }}
            th, td {{ padding: 0.75rem; text-align: left; border-bottom: 1px solid #e2e8f0; }}
            th {{ background: #f1f5f9; font-weight: 600; }}
            .commentary {{ background: #eff6ff; border-left: 4px solid #3b82f6; padding: 1rem 1.5rem; margin: 1.5rem 0; border-radius: 0 4px 4px 0; }}
        </style>
    </head>
    <body>
        <h1>Rapport SEO — Semaine du 12 au 18 mai 2026</h1>
        <p>Généré automatiquement le {datetime.now().strftime('%d/%m/%Y à %H:%M')}</p>
        
        <div class="metric-grid">
            <div class="metric-card">
                <div class="metric-label">Clics totaux</div>
                <div class="metric-value">42,847</div>
                <div class="metric-delta negative">-3.2% vs S-1</div>
            </div>
            <!-- ... autres métriques ... -->
        </div>
        
        <h2>Pages avec les plus fortes variations</h2>
        <div id="chart-movers"></div>
        <script>
            var data = {fig_movers.to_json()};
            Plotly.newPlot('chart-movers', data.data, data.layout);
        </script>
        
        <div class="commentary">
            <strong>Analyse automatique :</strong> 6 des 10 pages en baisse appartiennent au répertoire 
            /randonnee/. La position moyenne de ce répertoire est passée de 4.2 à 5.8. 
            Corrélation probable avec la perte des rich results FAQ sur ces pages.
        </div>
        
        <h2>Opportunités Quick Win</h2>
        <table>
            <tr><th>Page</th><th>Position moy.</th><th>Impressions</th><th>CTR</th><th>CTR attendu</th></tr>
            <!-- Injecté dynamiquement -->
        </table>
    </body>
    </html>
    """
    
    with open('rapport_seo_s20.html', 'w', encoding='utf-8') as f:
        f.write(report_html)
    
    return 'rapport_seo_s20.html'

L'avantage du HTML standalone : partageable par email, stockable dans un Google Drive, consultable sans outil spécifique. Pour une conversion en PDF, un simple playwright pdf rapport_seo_s20.html rapport_seo_s20.pdf fait le travail.

Automatiser les commentaires analytiques

Le reporting sans analyse est un dashboard. Ce qui fait la valeur d'un rapport stakeholders, ce sont les commentaires contextuels. C'est là que Claude Code apporte un avantage décisif par rapport à un script Python classique.

Faire rédiger l'analyse par Claude Code

Après avoir calculé les métriques, vous pouvez demander à Claude Code de générer les commentaires en langage naturel. La clé : fournir le contexte business dans votre prompt.

Un exemple de workflow dans Claude Code :

1. Le script Python s'exécute et génère les DataFrames d'analyse
2. Vous demandez à Claude Code : "Analyse les résultats. Contexte : nous avons migré 47 URLs de /equipement/chaussures/ vers /chaussures-trail/ le 8 mai. Rédige un paragraphe de synthèse pour le comité de direction, en français, max 150 mots, focus sur l'impact business."
3. Claude Code produit : "La migration des 47 URLs chaussures, effective le 8 mai, montre des signaux encourageants à J+10. Les nouvelles URLs captent 78% du trafic des anciennes (1 240 clics vs 1 590 pré-migration). 3 URLs n'ont pas encore été réindexées — vérification des redirections 301 recommandée. La catégorie /chaussures-trail/ gagne 2 positions en moyenne sur les requêtes "chaussures trail [marque]". Projection à J+30 : retour au niveau pré-migration si les 3 URLs bloquées sont corrigées cette semaine."

Ce type de commentaire contextuel est impossible à automatiser avec Looker Studio ou Google Sheets. C'est du traitement du langage sur des données structurées, exactement ce pour quoi les LLM sont pertinents.

Edge case : quand l'analyse automatique se trompe

Un LLM peut sur-interpréter une corrélation. Si le trafic d'une catégorie baisse la semaine d'un long weekend, Claude Code pourrait attribuer ça à un problème SEO alors que c'est simplement saisonnier.

Deux garde-fous :

• Injectez les données de l'année précédente pour la même période. Si le pattern est similaire, c'est saisonnier.
• Ajoutez dans votre prompt : "Avant d'attribuer une cause, vérifie si la variation est cohérente avec la saisonnalité (données Y-1 fournies) et avec les variations du marché (données par device et par pays)."

Ne faites jamais confiance aveuglément à un commentaire auto-généré. Relisez-le, surtout avant de l'envoyer à votre C-level.

Intégrer des sources de données tierces

Le vrai potentiel de ce pipeline apparaît quand vous croisez les données GSC avec d'autres sources. Voici les croisements les plus utiles.

GSC + Screaming Frog : identifier les régressions techniques qui impactent le trafic

Exportez un crawl Screaming Frog en CSV (Internal_All.csv) et croisez avec les données GSC :

import pandas as pd

# Charger l'export Screaming Frog
sf = pd.read_csv('Internal_All.csv', usecols=[
    'Address', 'Status Code', 'Indexability', 'Title 1', 
    'Meta Description 1', 'H1-1', 'Canonical Link Element 1',
    'Word Count'
])

# Normaliser les URLs pour le join
sf['page'] = sf['Address'].str.rstrip('/')
df_current['page_clean'] = df_current['page'].str.rstrip('/')

# Croisement
merged = df_current.merge(sf, left_on='page_clean', right_on='page', how='left')

# Pages avec du trafic GSC mais un problème technique
issues = merged[
    (merged['clicks'] > 10) & 
    (
        (merged['Indexability'] == 'Non-Indexable') |
        (merged['Status Code'] != 200) |
        (merged['Canonical Link Element 1'] != merged['Address'])
    )
]

print(f"ALERTE : {len(issues)} pages avec du trafic ont un problème technique")
print(issues[['page_clean', 'clicks', 'Status Code', 'Indexability', 'Canonical Link Element 1']].to_string())

Sur notre e-commerce outdoor de 12 000 pages, ce croisement a identifié 23 pages produit qui généraient encore 340 clics/semaine mais retournaient un 301 vers une page de catégorie générique — résultat d'une mise à jour de catalogue bâclée. 340 clics × taux de conversion moyen de 2.1% × panier moyen de 89€ = 640€ de revenu hebdomadaire en danger.

Ce genre de croisement est exactement le type de régression qu'un outil comme Seogard détecte automatiquement et en continu, sans attendre le rapport hebdomadaire.

GSC + données AI Search

Avec l'expansion des liens dans les résultats AI de Google, il devient pertinent de croiser vos données GSC avec votre visibilité dans les AI Overviews. Si vous trackez les requêtes où vos pages apparaissent dans les résultats de recherche AI, vous pouvez comparer le CTR de ces requêtes avec celles qui déclenchent des résultats classiques.

Le challenge actuel : Google ne fournit toujours pas de données de clics spécifiques aux AI Overviews dans la GSC. Vous devez donc utiliser des proxys — des outils tiers de SERP tracking pour identifier les requêtes qui déclenchent des AI Overviews, puis croiser avec vos données GSC.

Orchestrer le workflow : du one-shot au cron job

Claude Code est interactif par nature. Pour un workflow récurrent, vous avez deux options.

Option 1 : script Python autonome déclenché par cron

Vous utilisez Claude Code pour développer le script, puis vous l'exécutez de manière autonome via cron ou un scheduler comme GitHub Actions :

# .github/workflows/seo-report.yml
name: Weekly SEO Report
on:
  schedule:
    - cron: '0 7 * * 1'  # Chaque lundi à 7h UTC
  workflow_dispatch:  # Déclenchement manuel possible

jobs:
  generate-report:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      
      - name: Install dependencies
        run: pip install -r requirements.txt
      
      - name: Generate report
        env:
          GSC_CREDENTIALS: ${{ secrets.GSC_CREDENTIALS }}
        run: python generate_report.py
      
      - name: Send via email
        uses: dawidd6/action-send-mail@v3
        with:
          server_address: smtp.gmail.com
          server_port: 465
          username: ${{ secrets.MAIL_USER }}
          password: ${{ secrets.MAIL_PASS }}
          subject: "Rapport SEO Hebdomadaire — Semaine ${{ env.WEEK_NUMBER }}"
          to: [email protected],[email protected]
          from: [email protected]
          attachments: rapport_seo_*.html

Option 2 : Claude Code en mode assisté pour l'analyse ad-hoc

Gardez le script de récupération des données en automatique, mais utilisez Claude Code manuellement pour l'analyse quand vous avez un contexte spécifique à injecter (migration en cours, core update Google, événement saisonnier).

L'option 1 couvre 80% des besoins. L'option 2 est votre super-pouvoir pour les semaines atypiques — typiquement après un core update qui redistribue les cartes.

Les limites à connaître avant de se lancer

Ce pipeline n'est pas sans friction. Quelques réalités à garder en tête :

Quota API GSC : la limite de 1 200 requêtes/minute est généreuse pour un seul site, mais si vous gérez un portefeuille de 20 domaines pour un grand compte, vous allez la toucher. Implémentez un rate limiter (time.sleep(0.1) entre les appels suffit dans la plupart des cas).

Latence des données GSC : 3 jours minimum. Votre rapport du lundi reflète les données jusqu'à vendredi au mieux. Pour du monitoring en temps réel, la GSC ne suffit pas — vous avez besoin de données de crawl et de monitoring continu.

Coût Claude Code : chaque exécution de code consomme des tokens. Pour un rapport hebdomadaire standard, comptez environ 5 000-10 000 tokens par génération. Raisonnable, mais ça s'additionne si vous itérez beaucoup.

Reproductibilité : Claude Code peut générer un code légèrement différent à chaque exécution. Si la cohérence semaine-après-semaine est critique (et elle l'est pour un reporting C-level), figez le code généré dans un script Python versionné et ne refaites appel à Claude Code que pour les évolutions.

Sécurité : vos credentials OAuth ne doivent jamais être passées en clair dans un prompt Claude Code. Utilisez des variables d'environnement ou un secret manager. Le fichier token.json généré par l'authentification OAuth donne un accès en lecture à toutes vos propriétés GSC — traitez-le comme un mot de passe.

Le pipeline en pratique : ce qui change dans votre semaine

Ce workflow remplace un processus de reporting fragile et chronophage par un pipeline reproductible. Les données GSC sont récupérées automatiquement, croisées avec vos exports techniques, analysées avec une logique métier que vous contrôlez, et présentées dans un format adapté à chaque audience.

L'investissement initial est de 2-3 heures pour mettre en place le script, configurer l'authentification OAuth, et calibrer les seuils d'analyse. Le retour : chaque semaine, vous récupérez 2-3 heures de travail manuel, et surtout vous obtenez un rapport plus riche, plus rapide, et plus fiable que ce qu'un humain produirait en manipulant des CSV.

Pour les régressions critiques entre deux rapports — une meta title qui disparaît, un canonical qui casse, un bloc de pages qui passe en noindex — un outil de monitoring continu comme Seogard reste indispensable. Le rapport hebdomadaire analyse les tendances. Le monitoring temps réel attrape les urgences.