Comment scraper Google AI Modela réponse, ses citations et les liens en JSON

Google AI Mode a changé l'apparence d'un résultat de recherche. Au lieu de dix liens bleus, la surface de réponse IA renvoie une réponse rédigée à votre requête, avec un ensemble de sources citées en dessous et une bande plus large de liens connexes sur le côté. Pour quiconque suit ce que Google dit sur un sujet, c'est un nouveau jeu de données précieux : non seulement qui se classe, mais la réponse réelle liée à une requête et les pages que Google a choisies pour l'étayer.

Ce guide vous montre comment scraper Google AI Mode de manière fiable. Vous construirez un petit script Python fonctionnel qui récupère le résultat public d'AI Mode via la Crawling API, qui rend la page à forte intensité JavaScript derrière une IP de confiance, puis extrait la réponse IA, ses citations et les liens connexes en JSON structuré propre. La récupération et la rotation sont gérées pour vous, vous consacrez donc votre temps aux données, pas à maintenir en vie un navigateur headless et un pool de proxies.

Ce qu'est Google AI Mode et pourquoi le scraper

AI Mode est la couche de réponse générative à l'intérieur de Google Search. Vous y accédez en ajoutant le paramètre udm=50 à une URL de recherche normale, ce qui indique à Google de renvoyer sa réponse rédigée par IA plutôt que la page de résultats classique. La réponse se compose de trois parties qui comptent pour le scraping : le texte de réponse lui-même, les citations que Google attache à cette réponse, et un ensemble plus large de liens de référence liés à la requête.

Cette structure est ce qui vaut la peine d'être collectée. Vous pouvez suivre comment la réponse de Google à une requête évolue dans le temps, voir quels domaines il cite et à quelle fréquence, et alimenter cela dans des recherches SEO ou des workflows de contenu. C'est la même famille de problème que la construction de tout outil de données de moteur de recherche, sauf que la charge utile est une réponse plus ses sources plutôt qu'une liste classée.

Ce que vous allez construire

Un court script Python qui prend une requête de recherche, construit l'URL AI Mode, l'envoie via la Crawling API avec le rendu JavaScript activé, et analyse le résultat rendu en un objet JSON avec trois champs : le texte de réponse, une liste de citations et une liste de liens connexes. Chaque extrait fonctionne tel quel une fois que vous avez renseigné votre token, et le même code fonctionne que vous le pointiez sur une seule requête ou le boucliiez sur des centaines.

Pourquoi une simple requête échoue ici

Si vous demandez une URL AI Mode avec un client HTTP basique, vous obtenez une réponse avec le statut 200 et aucune réponse dans le corps. Deux facteurs jouent contre vous. D'abord, AI Mode est rendu dans le navigateur : la réponse et ses citations se chargent en flux après l'exécution du JavaScript de la page, donc le HTML initial est une coquille vide. Ensuite, Google challenge rapidement le trafic automatisé. Les IP de datacenter et les patterns de requêtes qui ne ressemblent pas à un vrai visiteur reçoivent un CAPTCHA ou un blocage avant de voir la réponse rendue.

Un scraper AI Mode fonctionnel a donc besoin de deux choses en une seule requête : un navigateur qui rend réellement la page, et une IP que Google considère comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur headless et un pool de proxies résidentiels rotatifs, mais les assembler et les maintenir en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : envoyez-lui l'URL avec un token JavaScript, elle rend la page derrière une IP de confiance, et elle vous remet le HTML finalisé à analyser.

Étape 1 : Construire l'URL AI Mode

Le point d'entrée du pipeline est une fonction qui transforme une requête en une URL AI Mode valide. Vous définissez udm=50 pour sélectionner AI Mode, passez la requête dans q, et ajoutez gl et hl pour contrôler le pays et la langue afin que les résultats soient cohérents d'une exécution à l'autre.

from urllib.parse import urlencode, quote_plus

def build_ai_mode_url(query, gl="us", hl="en"):
    if not query or not query.strip():
        raise ValueError("query must be non-empty")
    params = {
        "udm": "50",
        "q": query.strip(),
        "gl": gl,
        "hl": hl,
    }
    query_string = urlencode(params, quote_via=quote_plus)
    return f"https://www.google.com/search?{query_string}"

print(build_ai_mode_url("best ai tools for developers"))

Passez une requête et vous obtenez une URL AI Mode cohérente en retour. À partir de là, le reste du workflow est une ligne droite : envoyez l'URL via la Crawling API, puis normalisez le résultat rendu en champs structurés que votre système peut utiliser.

Étape 2 : Récupérer la page rendue avec la Crawling API

Avec l'URL construite, récupérez la page rendue. Vous passez deux options qui comptent pour une surface IA : ajax_wait indique à l'API d'attendre que le contenu asynchrone ait fini de se charger, et page_wait maintient un nombre fixe de millisecondes après le chargement pour que la réponse et les citations en flux aient le temps d'apparaître avant la capture de la page. Cinq secondes est un bon point de départ ; augmentez si la réponse revient maigre.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})

def fetch_html(target_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(target_url, options)
    return response["body"].decode("utf-8")

url = build_ai_mode_url("best ai tools for developers")
html = fetch_html(url)
print(html[:500])

Exécutez ceci et vous devriez voir le vrai balisage avec le bloc de réponse IA dedans, pas la coquille vide qu'une simple requête renvoie. Cela confirme que le rendu fonctionne avant d'écrire un seul sélecteur. Vous n'avez plus affaire à l'état du navigateur ni aux challenges anti-bot ; vous avez du HTML finalisé prêt pour le parseur.

Étape 3 : Extraire la réponse, les citations et les liens

Avec le HTML rendu en main, chargez-le dans un parseur et extrayez les trois champs qui comptent. Utilisez BeautifulSoup pour lire le texte de réponse, puis parcourez les blocs de citations et de liens pour collecter leurs URLs et titres. Le balisage d'AI Mode n'est pas un contrat public, donc traitez les sélecteurs ci-dessous comme un modèle de départ : inspectez une page AI Mode en direct dans les outils de développement de votre navigateur et confirmez-les par rapport à la mise en page actuelle.

from bs4 import BeautifulSoup

def extract_ai_mode(html):
    soup = BeautifulSoup(html, "html.parser")

    answer_block = soup.select_one('div[data-rl="ai-mode"], div.ai-response')
    response_text = answer_block.get_text(" ", strip=True) if answer_block else ""

    citations = []
    for cite in soup.select('a.ai-citation, div.citation a[href]'):
        href = cite.get("href", "")
        if href.startswith("http"):
            citations.append({
                "url": href,
                "title": cite.get_text(strip=True),
            })

    links = []
    for link in soup.select('div.related-links a[href^="http"]'):
        links.append({
            "url": link["href"],
            "title": link.get_text(strip=True),
        })

    return {
        "response_text": response_text,
        "citations": citations,
        "links": links,
    }

Chaque champ correspond directement à la façon dont AI Mode présente une réponse. response_text est la réponse générée que vous pouvez stocker, comparer ou afficher. citations sont les sources que Google a attachées pour étayer cette réponse, chacune avec son URL et son titre. links sont l'ensemble plus large de résultats connexes autour de la requête. Garder le schéma aussi petit est délibéré : trois champs stables couvrent la plupart des tableaux de bord et pipelines sans vous enfermer dans un balisage qui change.

Étape 4 : Tout assembler et sauvegarder le résultat

Maintenant, combinez les trois étapes en un seul script fonctionnel. Il construit l'URL, récupère la page rendue, extrait les champs et écrit le résultat structuré dans un fichier JSON que vous pouvez inspecter ou charger en aval.

import json
from urllib.parse import urlencode, quote_plus
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})

def build_ai_mode_url(query, gl="us", hl="en"):
    params = {"udm": "50", "q": query.strip(), "gl": gl, "hl": hl}
    return f"https://www.google.com/search?{urlencode(params, quote_via=quote_plus)}"

def fetch_html(target_url):
    options = {"ajax_wait": "true", "page_wait": 5000}
    response = api.get(target_url, options)
    return response["body"].decode("utf-8")

def extract_ai_mode(html):
    soup = BeautifulSoup(html, "html.parser")
    answer_block = soup.select_one('div[data-rl="ai-mode"], div.ai-response')
    response_text = answer_block.get_text(" ", strip=True) if answer_block else ""
    citations = [
        {"url": c["href"], "title": c.get_text(strip=True)}
        for c in soup.select('a.ai-citation, div.citation a[href^="http"]')
    ]
    links = [
        {"url": l["href"], "title": l.get_text(strip=True)}
        for l in soup.select('div.related-links a[href^="http"]')
    ]
    return {"response_text": response_text, "citations": citations, "links": links}

def scrape_ai_mode(query, gl="us", hl="en"):
    url = build_ai_mode_url(query, gl, hl)
    html = fetch_html(url)
    data = extract_ai_mode(html)
    data["query"] = query
    return data

if __name__ == "__main__":
    result = scrape_ai_mode("best ai tools for developers")
    with open("ai_mode.json", "w") as f:
        json.dump(result, f, indent=2)
    print(json.dumps(result, indent=2))

Exécutez-le avec python scraper.py et vous obtenez la réponse structurée écrite dans ai_mode.json et affichée dans la console. La fonction scrape_ai_mode est aussi le seul endroit à importer si vous souhaitez intégrer ceci dans votre propre application : appelez-la avec une requête et vous récupérez le même dict structuré, sans analyse supplémentaire nécessaire.

À quoi ressemble la sortie

Le résultat est un seul objet avec le texte de réponse et deux listes. Un exemple tronqué :

{
  "query": "best ai tools for developers",
  "response_text": "Popular AI tools for developers include code assistants, ...",
  "citations": [
    { "url": "https://example.com/ai-dev-tools", "title": "10 AI Tools for Developers" },
    { "url": "https://example.org/coding-assistants", "title": "Best Coding Assistants" }
  ],
  "links": [
    { "url": "https://example.net/dev-productivity", "title": "Developer Productivity Guide" }
  ]
}

Cette forme suffit pour suivre une réponse dans le temps, compter quels domaines Google cite le plus, ou comparer les réponses entre régions en faisant varier gl et hl. Stockez le texte de réponse avec un horodatage et vous avez un historique simple de la façon dont la réponse de Google à une requête évolue.

Passer à grande échelle sur de nombreuses requêtes

Une seule requête est une démonstration ; un vrai travail boucle sur une liste. La forme reste la même : bouclez les requêtes, scrapez chacune et collectez les lignes. Ce qu'il faut bien faire à grande échelle, c'est rester non bloqué, car Google surveille le trafic ressemblant à des scrapers. La Crawling API effectue une rotation des IP pour vous à chaque appel, donc la boucle ci-dessous n'a pas à gérer les proxies.

queries = [
    "best ai tools for developers",
    "how does web scraping work",
    "python vs javascript for automation",
]

results = []
for q in queries:
    try:
        results.append(scrape_ai_mode(q))
    except Exception as err:
        print(f"Skipped {q}: {err}")

with open("ai_mode_batch.json", "w") as f:
    json.dump(results, f, indent=2)

Si vous préférez router votre propre trafic via un pool rotatif plutôt que d'utiliser la Crawling API de bout en bout, le Smart AI Proxy (aussi appelé le AI Proxy) vous offre la même rotation d'IP résidentielles comme endpoint proxy drop-in. Pour le guide complet sur la santé d'un scraping Google, consultez comment faire une rotation de proxies pour scraper les résultats de recherche Google et comment scraper des sites web sans se faire bloquer.

Problèmes courants et solutions

Scraper une surface Google n'est pas une tâche que l'on configure une fois pour toutes. Les charges utiles changent et votre parseur doit être flexible. Les problèmes les plus fréquents sont simples :

• Texte de réponse vide. Si response_text revient vide, la page n'avait probablement pas fini de se rendre. Augmentez page_wait, confirmez que vous utilisez le token JS, et réinspectez le sélecteur du bloc de réponse par rapport à une page en direct.
• Erreurs d'authentification ou de crédit. Une requête qui échoue avant le rendu signifie généralement un mauvais token ou un solde vide. Vérifiez que votre token JS est correct et que votre compte a des crédits, et examinez le comportement de l'API quand Google challenge le trafic.
• Citations ou liens manquants. Google déplace ces blocs. Quand ils cessent de correspondre, mettez à jour les sélecteurs de citation et de lien, et gardez un échantillon de HTML brut pour voir exactement ce qui a changé.

Quand les résultats chutent soudainement ou semblent différents, comparez un récent échantillon de HTML brut avec un plus ancien. Cela vous dit généralement directement si le changement est dans votre logique d'analyse ou en amont dans la page rendue.

Est-il légal de scraper Google AI Mode ?

La question de savoir si le scraping de Google AI Mode est autorisé dépend des conditions d'utilisation de Google, de votre juridiction et de ce que vous faites avec les données. Les conditions de Google restreignent l'accès automatisé à ses services, donc le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de vos outils. Aucun code ici ne change cela ; il fait seulement fonctionner la partie technique. Lisez les Conditions d'utilisation de Google et son robots.txt avant de l'utiliser à grande échelle en production, et décidez en conséquence.

Quelques lignes à respecter. Collectez uniquement les résultats AI Mode publics, la réponse et les sources que tout le monde peut voir sans se connecter. Maintenez votre taux de requêtes suffisamment bas pour ne pas surcharger les systèmes de Google, et respectez les attentes de débit que son robots.txt signale. Ne collectez jamais de données personnelles ou privées, et n'essayez pas d'accéder à quoi que ce soit derrière une connexion. Si vous prévoyez de réutiliser les données commercialement, obtenez une autorisation ou un accord de données officiel plutôt que de supposer que le silence vaut consentement.

Ce guide est délibérément limité aux résultats AI Mode publics car c'est la ligne qui rend le travail défendable. Il ne couvre pas les données protégées par connexion ou privées, les informations de compte ou de profil, ni aucune tentative de contournement de l'authentification. Si votre projet nécessite plus que la surface publique de réponse, la bonne décision est un accord de données officiel avec Google, pas un scraper plus astucieux.

Foire aux questions

Qu'est-ce que udm=50 dans une URL de recherche Google ?

udm=50 est le paramètre de recherche qui déclenche Google AI Mode. La valeur udm sélectionne un secteur de recherche, et 50 est celui qui renvoie la surface de réponse IA plutôt que la liste classique de liens. Ajoutez-le à une URL google.com/search standard avec votre requête, votre pays et votre langue, et Google renvoie le résultat AI Mode pour cette requête.

Pourquoi une simple requête ne renvoie-t-elle aucune réponse de Google AI Mode ?

Parce qu'AI Mode est rendu côté client. La réponse et ses citations se chargent en flux après l'exécution du JavaScript de la page, donc une requête HTTP brute renvoie le statut 200 avec une coquille vide. Google challenge aussi rapidement le trafic automatisé. Pour obtenir la vraie réponse, vous devez rendre la page derrière une IP de confiance, ce que gère le token JS de la Crawling API.

Dois-je utiliser le token normal ou le token JS ?

Le token JS. Le token normal récupère le HTML statique, qui pour AI Mode est la même coquille vide qu'une simple requête renvoie. Le token JS rend d'abord la page dans un vrai navigateur, donc la réponse, les citations et les liens sont présents quand votre parseur les lit.

Quelles données puis-je extraire d'un résultat Google AI Mode ?

Trois champs stables couvrent la plupart des besoins : le texte de réponse généré, les citations que Google attache à cette réponse (chacune avec une URL et un titre), et l'ensemble plus large de liens connexes autour de la requête. Garder le schéma petit rend le pipeline résilient, car vous n'êtes pas enfermé dans un balisage que Google change sans préavis.

Mes sélecteurs retournent des chaînes vides. Qu'est-ce qui a changé ?

Presque certainement le balisage de Google. AI Mode n'a pas de noms de classes publiés et stables, donc les sélecteurs qui fonctionnaient le mois dernier peuvent casser. Réinspectez une page AI Mode en direct dans les outils de développement de votre navigateur et mettez à jour les sélecteurs de réponse, de citation et de lien. Garder un court échantillon de HTML brut à côté de votre sortie facilite la compréhension de ce qui a bougé.

Est-il légal de scraper Google AI Mode ?

Cela dépend des conditions d'utilisation de Google, de votre juridiction et de votre objectif, et les conditions de Google restreignent l'accès automatisé. Limitez-vous strictement aux résultats AI Mode publics, respectez robots.txt et les attentes de débit, et ne touchez jamais au contenu protégé par connexion, aux données personnelles ni à l'authentification. Pour une réutilisation commerciale, obtenez une autorisation ou un accord de données officiel plutôt que de vous fier à un scraper.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.

NZ

Neil Zamora

Architecte senior · Crawlbase

Architecte senior chez Crawlbase, axé sur les systèmes derrière le crawling à grande échelle : rotation de proxys, résilience anti-bot et les API qui masquent cette complexité.