Pour connecter Google Search Console à ChatGPT, vous pouvez installer une passerelle sur votre ordinateur et la relier à ChatGPT par un tunnel privé. ChatGPT peut alors consulter les clics, les impressions, le taux de clics et la position moyenne de votre site, puis les analyser à votre demande. Dans ce tutoriel, l'accès est limité à la lecture.

Cette méthode a été mise en œuvre chez DOPHIS, avec une lecture des données vérifiée depuis ChatGPT le 30 octobre 2026. Elle utilise l'API Search Console, un petit serveur MCP en Python et le client de tunnel OpenAI. Les exemples ci-dessous sont génériques : vous renseignez votre propre propriété et vos propres accès.

Que permet cette connexion à Search Console ?

Vous pouvez demander quelles pages perdent des clics, quelles recherches font apparaître votre site ou comment les résultats évoluent entre deux périodes. La passerelle permet de lire les performances par page, requête, date, pays et appareil. Elle fournit des données réelles à ChatGPT ; l'interprétation et les actions proposées restent à vérifier.

Ce connecteur concerne le référencement naturel mesuré dans Search Console. Il ne donne pas accès aux campagnes Google Ads, aux conversions GA4 ou à l'administration de WordPress. Il ne modifie ni vos pages ni les paramètres de votre propriété Google.

Pour une analyse ponctuelle, un export de Search Console joint à une conversation peut suffire. La connexion devient utile lorsque vous voulez refaire les mêmes analyses régulièrement, sans préparer un nouvel export à chaque fois.

Est-ce gratuit et que faut-il préparer ?

Google indique que l'utilisation de l'API Search Console est gratuite, dans les limites des quotas. Le montage présenté ne nécessite pas d'abonnement à un connecteur SEO tiers.

Ne confondez donc pas une API Google gratuite avec un accès garanti sur tous les comptes ChatGPT. Avant de commencer, vérifiez que votre interface permet d'ajouter un serveur MCP personnalisé et que vous pouvez créer ou utiliser un tunnel dans votre organisation OpenAI. La documentation consultée ne permet pas de garantir un coût global nul pour tous les comptes.

Il vous faut également un ordinateur Windows connecté à Internet, Python 3.13, un accès à Google Cloud et les droits de propriétaire sur votre propriété Search Console pour y ajouter un utilisateur. En entreprise, certaines opérations peuvent nécessiter l'intervention de l'administrateur.

1. Activer l'API Google Search Console

Ouvrez la console Google Cloud. Créez un projet pour cette connexion, ou sélectionnez un projet existant que vous administrez. Dans API et services → Bibliothèque, recherchez Google Search Console API, puis activez-la.

Dans IAM et administration → Comptes de service, créez un compte de service, par exemple gsc-lecture. Il s'agit du compte technique utilisé par le programme. Ne lui attribuez pas un rôle Propriétaire ou Éditeur sur tout le projet pour cette lecture : l'accès au site sera accordé dans Search Console.

Ouvrez ce compte, puis Clés → Ajouter une clé → Créer une clé → JSON. Téléchargez le fichier et conservez-le localement sous le nom google-service-account.json. La procédure Google de création des clés de compte de service précise les droits nécessaires et les éventuelles restrictions d'organisation.

Copiez aussi l'adresse du compte de service, sous la forme gsc-lecture@votre-projet.iam.gserviceaccount.com. C'est cette adresse que vous allez ajouter dans Search Console. Le fichier JSON contient une clé privée : ne le joignez pas à ChatGPT et ne le placez pas sur votre site.

2. Donner un accès restreint à votre propriété GSC

Dans Google Search Console, sélectionnez la propriété concernée. Ouvrez Paramètres → Utilisateurs et autorisations → Ajouter un utilisateur. Saisissez l'adresse du compte de service et choisissez l'autorisation Restreint.

Ce niveau permet notamment de consulter les performances. Il figure dans le tableau des autorisations Search Console. Lors de notre installation, Google a bien renvoyé le niveau siteRestrictedUser.

Notez ensuite l'identifiant exact de la propriété. Une propriété de domaine et une propriété avec préfixe d'URL sont deux périmètres différents :

La lecture seule repose aussi sur le programme : il demande uniquement la portée https://www.googleapis.com/auth/webmasters.readonly et n'expose que des opérations de consultation. Google distingue cette portée des autorisations d'écriture dans sa documentation d'authentification Search Console.

3. Installer la passerelle sur Windows

Installez Python 3.13 depuis la page officielle Python pour Windows si nécessaire. Ouvrez PowerShell, puis exécutez les commandes suivantes, une ligne après l'autre. Le dossier proposé est local et indépendant de vos fichiers de site.

py -3.13 --version
New-Item -ItemType Directory -Force -Path 'C:\Connecteur_IA\GSC'
Set-Location 'C:\Connecteur_IA\GSC'
py -3.13 -m venv venv
.\venv\Scripts\python.exe -m pip install --upgrade pip
.\venv\Scripts\python.exe -m pip install "mcp==1.30.0" "google-auth[requests]==2.62.0" "requests==2.34.2"

Si py -3.13 --version échoue, vérifiez l'installation de Python avant de poursuivre. Après les dernières commandes, les bibliothèques nécessaires doivent être installées dans le sous-dossier venv.

Placez le fichier google-service-account.json dans C:\Connecteur_IA\GSC. Dans ce même dossier, créez un fichier gsc_server.py contenant le code ci-dessous. Dans le Bloc-notes, choisissez le type Tous les fichiers et l'encodage UTF-8 pour éviter une extension cachée .txt.

Remplacez la valeur de SITE_URL, au début du code, par votre propriété exacte. Par exemple, remplacez sc-domain:example.com par votre domaine. Ne mettez aucune clé privée dans le code.

"""Passerelle Search Console local : outils de lecture exclusivement, transport stdio."""
from __future__ import annotations

import argparse
import json
import os
import re
import sys
from datetime import date, datetime, timedelta, timezone
from pathlib import Path
from typing import Literal
from urllib.parse import quote

from google.auth.exceptions import GoogleAuthError
from google.auth.transport.requests import AuthorizedSession
from google.oauth2 import service_account
from mcp.server.fastmcp import FastMCP
from mcp.types import ToolAnnotations
from pydantic import BaseModel, ConfigDict, Field
from requests.exceptions import RequestException

VERSION = "1.0.0"
SITE_URL = "sc-domain:example.com"  # Remplacer par votre propriete exacte
SCOPES = ("https://www.googleapis.com/auth/webmasters.readonly",)
SITE_ENDPOINT = "https://www.googleapis.com/webmasters/v3/sites/" + quote(SITE_URL, safe="")
DEFAULT_CREDENTIALS = str(Path(__file__).with_name("google-service-account.json"))
Dimension = Literal["date", "page", "query", "country", "device", "searchAppearance"]
SearchType = Literal["web", "image", "video", "news", "discover", "googleNews"]


class GSCError(RuntimeError):
    """Message public construit localement, sans contenu de credentials."""


class Filter(BaseModel):
    model_config = ConfigDict(extra="forbid")
    dimension: Literal["page", "query", "country", "device", "searchAppearance"]
    operator: Literal["equals", "notEquals", "contains", "notContains", "includingRegex", "excludingRegex"] = "equals"
    expression: str = Field(min_length=1, max_length=4096)


def _session() -> AuthorizedSession:
    path = Path(os.environ.get("GOOGLE_APPLICATION_CREDENTIALS", DEFAULT_CREDENTIALS))
    try:
        info = json.loads(path.read_text(encoding="utf-8-sig"))
        if info.get("type") != "service_account":
            raise GSCError("Le fichier Google doit etre une cle de compte de service.")
        if info.get("token_uri") != "https://oauth2.googleapis.com/token":
            raise GSCError("Adresse d'authentification Google inattendue dans le fichier local.")
        credentials = service_account.Credentials.from_service_account_info(info, scopes=SCOPES)
        return AuthorizedSession(credentials, refresh_timeout=20, max_refresh_attempts=1)
    except GSCError:
        raise
    except FileNotFoundError:
        raise GSCError("Fichier Google absent. Verifier google-service-account.json a cote de gsc_server.py.") from None
    except (OSError, ValueError, GoogleAuthError):
        raise GSCError("Impossible de lire la cle Google locale. Verifier le fichier et les droits Windows.") from None


def _read_google(operation: str, body: dict | None = None) -> dict:
    # Deux appels permis seulement. Le POST Search Analytics est une lecture.
    routes = 
    if operation not in routes:
        raise GSCError("Operation non autorisee : passerelle en lecture seule.")
    method, url = routes[operation]
    try:
        with _session() as session:
            response = session.request(method, url, json=body, timeout=(10, 35), allow_redirects=False)
    except GSCError:
        raise
    except GoogleAuthError:
        raise GSCError("Authentification Google refusee. Verifier que le compte de service et sa cle sont actifs.") from None
    except RequestException:
        raise GSCError("Connexion Google impossible ou delai depasse. Verifier Internet et reessayer.") from None
    if response.status_code != 200:
        hints = 
        raise GSCError(f"Google HTTP . " + hints.get(response.status_code, "Service indisponible ou reponse inattendue. Reessayer plus tard."))
    try:
        result = response.json()
    except ValueError:
        raise GSCError("Google a renvoye une reponse JSON invalide.") from None
    if not isinstance(result, dict):
        raise GSCError("Format de reponse Google inattendu.")
    return result


def _validated_body(start_date, end_date, dimensions, search_type, filters, limit, start_row, data_state):
    for value in (start_date, end_date):
        if not isinstance(value, str) or not re.fullmatch(r"\d-\d-\d", value):
            raise GSCError("Les dates doivent etre au format AAAA-MM-JJ.")
    try:
        first, last = date.fromisoformat(start_date), date.fromisoformat(end_date)
    except ValueError:
        raise GSCError("Date inexistante.") from None
    if first > last:
        raise GSCError("La date de debut doit preceder ou egaler la date de fin.")
    allowed = 
    if len(dimensions) != len(set(dimensions)) or any(d not in allowed for d in dimensions):
        raise GSCError("Dimensions invalides ou repetees.")
    if search_type not in :
        raise GSCError("Type de recherche invalide.")
    if data_state not in :
        raise GSCError("Etat des donnees invalide.")
    if type(limit) is not int or not 1 <= limit <= 2000:
        raise GSCError("limit doit etre compris entre 1 et 2000.")
    if type(start_row) is not int or not 0 <= start_row <= 100000:
        raise GSCError("start_row doit etre compris entre 0 et 100000.")
    if not dimensions and start_row != 0:
        raise GSCError("Pour un total sans dimensions, start_row doit etre 0.")
    if len(filters) > 10:
        raise GSCError("Dix filtres au maximum.")
    body = 
    if filters:
        body["dimensionFilterGroups"] = []
    return body


mcp = FastMCP(
    "Search Console local", log_level="WARNING",
    instructions=f"Lecture seule de . Utiliser gsc_performance avec dimensions=[] pour les totaux et avec page/query/date/country/device pour les details. Ne pas sommer des listes de mots-cles pour reconstruire les totaux : Google masque des requetes et limite les lignes. Les dates sont celles de Search Console (heure du Pacifique). Le CTR est fourni en pourcentage. Verifier has_more et next_start_row pour paginer. Par defaut les donnees sont finalisees; une absence de lignes ne prouve pas une absence de trafic. Aucun outil ne modifie Google ou le site."
)
READ_ONLY = ToolAnnotations(readOnlyHint=True, destructiveHint=False, idempotentHint=True, openWorldHint=True)


@mcp.tool(annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False, idempotentHint=True, openWorldHint=False))
def gsc_status() -> dict:
    """Verifie la reponse de la passerelle, sans contacter Google. Ne prouve pas l'acces aux donnees."""
    return 


@mcp.tool(annotations=READ_ONLY)
def gsc_check_access() -> dict:
    """Teste reellement l'acces Google a la propriete configuree et renvoie le niveau de permission."""
    result = _read_google("property")
    if result.get("siteUrl") != SITE_URL or result.get("permissionLevel") == "siteUnverifiedUser":
        raise GSCError("La propriete attendue n'est pas accessible ou n'est pas verifiee.")
    return 


@mcp.tool(annotations=READ_ONLY)
def gsc_performance(
    start_date: str, end_date: str, dimensions: list[Dimension] | None = None,
    search_type: SearchType = "web", filters: list[Filter] | None = None,
    limit: int = 100, start_row: int = 0, data_state: Literal["final", "all"] = "final",
) -> dict:
    """Lit clics, impressions, CTR (%) et position moyenne pour la propriete configuree.

    Dates inclusives AAAA-MM-JJ, fuseau du Pacifique. dimensions=[] (defaut) donne
    le total Google; ['query'], ['page'], ['date'] ou combinaisons donnent le detail.
    Filtres combines par ET, ex. .
    limit: 1..2000. Reprendre next_start_row avec les memes autres parametres si has_more.
    data_state='final' exclut les donnees provisoires, 'all' peut en contenir.
    Le resultat reste soumis aux limites internes et requetes anonymisees de Google.
    """
    dims = list(dimensions or [])
    fs = list(filters or [])
    body = _validated_body(start_date, end_date, dims, search_type, fs, limit, start_row, data_state)
    result = _read_google("performance", body)
    source_rows = result.get("rows", [])
    has_more = len(source_rows) > limit
    rows = []
    for raw in source_rows[:limit]:
        row = dict(zip(dims, raw.get("keys", [])))
        row.update(clicks=raw.get("clicks", 0), impressions=raw.get("impressions", 0),
                   ctr_percent=round(raw.get("ctr", 0) * 100, 6), position=raw.get("position"))
        rows.append(row)
    return 


def test_access() -> int:
    try:
        access = gsc_check_access()
        end = datetime.now(timezone.utc).date() - timedelta(days=3)
        start = end - timedelta(days=27)
        data = gsc_performance(start.isoformat(), end.isoformat())
        print("CONNEXION GSC OK")
        print("Propriete : " + access["property"])
        print("Permission Google : " + str(access["permission"]))
        print("Autorisation technique : webmasters.readonly")
        print(f"Test de lecture :  au  (dates GSC / Pacifique)")
        if data["rows"]:
            row = data["rows"][0]
            print(f"Clics :  | Impressions : ")
        else:
            print("Lecture acceptee ; aucune ligne sur cette periode. Ce resultat n'est pas une erreur d'acces.")
        return 0
    except GSCError as exc:
        print("ECHEC DU TEST GSC : " + str(exc), file=sys.stderr)
        return 1


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--test-access", action="store_true")
    args = parser.parse_args()
    if args.test_access:
        raise SystemExit(test_access())
    mcp.run(transport="stdio")

Ce serveur propose trois outils : vérifier la réponse de la passerelle, tester l'accès Google et lire les performances. Le code est une adaptation générique de la passerelle utilisée chez DOPHIS. Ses contrôles et sa communication MCP ont été vérifiés hors connexion ; le test suivant valide vos propres accès Google.

4. Tester la lecture de Search Console avant de créer le tunnel

Dans PowerShell, exécutez :

Set-Location 'C:\Connecteur_IA\GSC'
.\venv\Scripts\python.exe gsc_server.py --test-access

Le résultat attendu commence par CONNEXION GSC OK, puis indique votre propriété, l'autorisation webmasters.readonly et une période de lecture. Si Google dispose de données pour cette période, le programme affiche les clics et impressions.

Ce test contacte réellement Google. Un résultat sans ligne peut correspondre à une période sans données accessibles ; ce n'est pas à lui seul une erreur d'authentification. En revanche, un refus d'accès doit être corrigé avant le raccordement à ChatGPT.

5. Créer le tunnel OpenAI

Dans la plateforme OpenAI, ouvrez Settings → Tunnels → Create tunnel. Donnez-lui un nom identifiable, par exemple Search Console personnel, et une description : Lecture seule des performances Search Console de mon site.

Sélectionnez l'organisation OpenAI et l'espace ChatGPT qui utiliseront ce tunnel. Dans notre configuration personnelle, aucune liste de réseaux d'entrée autorisés n'a été ajoutée : la case Restrict client network access est restée décochée. Dans un espace d'entreprise, appliquez la règle réseau définie par votre administrateur.

Après création, conservez l'identifiant commençant par tunnel_. Créez également une clé d'exécution OpenAI autorisée à utiliser le tunnel. Les droits de création sont Tunnels Read + Manage ; l'exécution et la sélection du tunnel demandent Read + Use. Ces autorisations sont décrites dans la documentation OpenAI sur les tunnels MCP.

Téléchargez le client depuis les versions officielles de tunnel-client. La version utilisée pour notre installation était la 0.0.18. Choisissez l'archive Windows correspondant à votre ordinateur, extrayez-la et placez l'exécutable sous le nom tunnel-client.exe dans C:\Connecteur_IA\GSC.

Si vous utilisez déjà un autre connecteur local, créez un tunnel distinct pour cette passerelle. Avec ce mode de fonctionnement, un identifiant de tunnel ne doit pas être partagé par plusieurs clients actifs.

6. Lancer la passerelle par un double-clic

Dans le même dossier, créez Lancer-GSC.ps1 avec le contenu suivant. Le lanceur mémorise seulement l'identifiant du tunnel dans tunnel-id.txt. Il demande la clé OpenAI avec une saisie masquée à chaque démarrage et ne l'enregistre pas sur disque.

$ErrorActionPreference = 'Stop'
$secureKey = $null
$keyPointer = [IntPtr]::Zero

try  catch  finally 

Créez ensuite Lancer-GSC.cmd avec ces trois lignes :

@echo off
powershell.exe -NoProfile -ExecutionPolicy Bypass -File "%~dp0Lancer-GSC.ps1"
pause

L'option ExecutionPolicy Bypass s'applique uniquement au processus lancé ; elle ne modifie pas durablement la stratégie PowerShell de Windows. Sur un poste administré, faites valider l'exécution selon les règles de votre organisation.

Double-cliquez sur Lancer-GSC.cmd. Au premier démarrage, indiquez le tunnel, puis collez la clé OpenAI dans la saisie masquée. Laissez la fenêtre ouverte pendant l'utilisation de ChatGPT.

Sur ce même ordinateur, ouvrez http://127.0.0.1:63719/ui. Le tunnel doit être connecté et prêt à traiter les appels. Cette adresse est un écran de contrôle local, pas l'adresse à saisir comme serveur dans ChatGPT. Les paramètres de lancement sont décrits dans la configuration officielle de tunnel-client.

7. Ajouter le connecteur dans ChatGPT et valider la connexion

Dans ChatGPT sur le Web, ouvrez Applications / Plugins → + → Ajouter un serveur MCP personnalisé. Renseignez les champs suivants :

Le choix Aucune concerne l'authentification supplémentaire de ce serveur MCP local. Le tunnel utilise la clé OpenAI et l'accès Google repose sur votre compte de service.

Lisez l'avertissement, créez le plugin, puis installez-le ou activez-le dans la conversation. Vous pouvez le sélectionner avec @. Le parcours est décrit dans le guide OpenAI d'ajout d'un serveur MCP personnalisé.

Demandez ensuite un test concret :

Utilise mon connecteur Search Console. Vérifie l'accès à ma propriété, puis affiche les clics, impressions, CTR et position moyenne sur la période du test local. Indique les dates exactes, le type de recherche et la propriété interrogée. Pour les totaux, utilise gsc_performance avec dimensions=[] et les données finalisées.

Comparez les clics et impressions avec le test local, en conservant les mêmes dates, le type Web et les mêmes filtres. La connexion est validée lorsque ChatGPT lit réellement les données. Voir le plugin dans une liste ou obtenir une réponse de gsc_status ne suffit pas.

Quelles demandes faire à ChatGPT avec les données GSC ?

Repérer les pages qui perdent des clics

Compare deux périodes consécutives de 28 jours avec des données finalisées. Précise les dates retenues. Présente les pages qui perdent le plus de clics, avec leurs impressions, CTR et position moyenne sur les deux périodes. Distingue ce que les données montrent des causes possibles à vérifier.

Identifier des pages à examiner pour améliorer le CTR

Sur la période étudiée, repère les couples page-requête ayant au moins 100 impressions et une position moyenne comprise entre 4 et 15. Ce seuil est un critère de tri, pas une règle SEO universelle. Présente le CTR et propose les vérifications utiles avant de réécrire un titre. Signale si la liste analysée est partielle.

Analyser une page précise

Pour l'URL que je vais te donner, compare les performances sur deux périodes de même durée. Liste les principales requêtes, leur évolution et les différences entre mobile et ordinateur. Utilise un filtre sur la page exacte. Ne conclus pas à une cause technique à partir des seuls chiffres Search Console.

Ces demandes sont des exemples d'utilisation. Elles ne constituent pas des conclusions déjà établies sur votre site. Si la réponse s'appuie sur une liste de lignes, demandez à ChatGPT de vérifier la pagination avec has_more et next_start_row avant de présenter l'analyse comme couvrant les résultats renvoyés.

Les limites à connaître pour interpréter les résultats

La somme des requêtes peut différer du total du site. Google masque certaines recherches pour protéger la confidentialité et les tableaux ne restituent pas nécessairement toutes les lignes. Il faut demander les totaux séparément, sans dimension, puis utiliser les détails pour expliquer les tendances. Google décrit ces différences dans son aide sur les données Search Console.

La pagination ne garantit pas une extraction exhaustive. Elle permet de parcourir les lignes accessibles à cette requête. L'API reste soumise à ses limites internes. Le serveur proposé renvoie au maximum 2 000 lignes par appel, ce qui est un choix de ce programme, pas le plafond général de Google.

Les dates suivent le fuseau du Pacifique. Les données finalisées sont utilisées par défaut. Les chiffres des derniers jours peuvent donc être absents. Conservez les mêmes dates, filtres et types de recherche pour les comparaisons, conformément au fonctionnement de Search Analytics dans l'API Google.

Une position moyenne n'est pas un classement fixe. Elle agrège des apparitions différentes. De même, une baisse de clics ne prouve pas à elle seule qu'un contenu doit être réécrit : la demande, les impressions, les appareils et les requêtes observées doivent aussi être examinés.

Si vous exportez ensuite les résultats dans un classeur, notre guide pour créer et vérifier une formule Excel avec ChatGPT explique comment contrôler les calculs proposés avant de les appliquer à tout un tableau.

Que vérifier si la connexion ne fonctionne pas ?

Arrêtez l'ancienne fenêtre avec Ctrl+C avant de relancer le même tunnel. Si vous devez changer son identifiant, modifiez tunnel-id.txt dans votre dossier local. Ne transmettez jamais le contenu du fichier JSON Google ou la clé OpenAI dans une capture d'écran ou une demande d'assistance.

Questions fréquentes sur la connexion Search Console à ChatGPT

Peut-on connecter Search Console sans abonnement à un connecteur SEO ?

Oui, le montage présenté utilise une passerelle personnelle et l'API Google gratuite. Il reste nécessaire de disposer des fonctions et autorisations requises côté OpenAI. Vérifiez leurs conditions pour votre compte avant de commencer.

Faut-il laisser l'ordinateur allumé ?

Oui. Dans cette installation locale, le PC doit être allumé, connecté à Internet et le lanceur doit rester ouvert. Une mise en veille ou l'arrêt du programme interrompt les nouveaux appels. Après un redémarrage, relancez le fichier CMD.

ChatGPT peut-il modifier mon site avec cette passerelle ?

Non. Le code fourni n'expose que des lectures de Search Console. Il n'a pas d'accès à WordPress et ne propose aucune opération d'écriture. L'autorisation Google demandée est limitée à webmasters.readonly.

Faut-il donner le fichier JSON à ChatGPT ?

Non. Ce fichier reste sur le PC, à côté du programme. La passerelle l'utilise pour s'authentifier auprès de Google. ChatGPT reçoit les résultats demandés, pas la clé privée.

La connexion fonctionne-t-elle aussi avec une propriété préfixe d'URL ?

Oui, à condition de renseigner dans SITE_URL l'adresse exacte enregistrée dans Search Console, avec le protocole et le préfixe éventuel. Le compte de service doit avoir accès à cette même propriété.

Cette passerelle donne-t-elle aussi accès à GA4 ?

Non. GA4 utilise une autre API et ses propres autorisations. La connexion Search Console permet d'étudier les performances dans la recherche Google ; elle ne fournit pas les sessions, événements ou conversions de Google Analytics.

Comment retirer l'accès ?

Pour suspendre la connexion, fermez le lanceur. Pour la retirer durablement, supprimez l'accès du compte de service dans Search Console et retirez le plugin de ChatGPT. Révoquez les clés et supprimez le tunnel devenus inutiles, après avoir vérifié qu'ils ne servent pas à une autre connexion.