Web Scraping avec Gemini AI en PythonRécupérer, puis extraire

Le web scraping a toujours consisté en deux tâches collées ensemble : obtenir la page, puis en extraire les champs souhaités. La deuxième tâche est celle où la plupart des scrapers se dégradent. Vous écrivez des sélecteurs CSS ou XPath contre une mise en page, le site publie une refonte, et votre extraction renvoie silencieusement des chaînes vides. Les grands modèles de langage changent l'économie ici. Au lieu de décrire où une valeur se trouve dans le DOM, vous décrivez ce que vous voulez en anglais simple et laissez le modèle lire le contenu comme une personne le ferait.

Ce guide vous montre comment faire du web scraping avec Gemini AI en Python de manière fiable : utilisez l'API Crawling pour récupérer et rendre la page cible en HTML propre ou markdown, puis transmettez ce contenu à Google Gemini pour extraire du JSON structuré. La division du travail est importante et c'est tout le propos de cet article. Crawlbase s'occupe de la récupération et du rendu derrière un vrai navigateur et une IP de confiance ; Gemini s'occupe de la lecture et de la structuration. Chaque outil fait la partie pour laquelle il est réellement bon.

Pourquoi associer Gemini à une couche de récupération du tout

Gemini est un grand modèle de langage de Google. Il comprend le langage naturel, lit du contenu désordonné et renvoie des données structurées quand vous le demandez. Ce qu'il ne fait pas, c'est récupérer des pages web. Il n'a pas de client HTTP, pas de navigateur, pas de pool de proxies, et aucun moyen de passer les défenses anti-bot qui gardent la plupart des sites commerciaux. Donnez-lui une URL et il ne peut pas l'ouvrir ; donnez-lui du HTML brut que vous avez scraped vous-même et il extraira volontiers de tout ce que vous avez réussi à récupérer, y compris une coque vide.

C'est le vide que comble la couche de récupération. Les sites modernes rendent le contenu côté client et défient le trafic automatisé agressivement, donc un simple requests.get renvoie souvent un 200 sans aucune des données que vous cherchiez. Vous avez besoin d'un navigateur qui exécute réellement le JavaScript de la page et d'une IP que le site lit comme un vrai visiteur. Vous pouvez assembler cela vous-même avec un navigateur sans interface graphique plus des proxies résidentiels rotatifs, mais maintenir ce stack en bon état représente l'essentiel du travail. L'API Crawling intègre les deux en un seul appel : envoyez-lui une URL avec un token JavaScript, elle rend la page et renvoie le HTML finalisé, prêt pour Gemini.

Ce que vous allez construire

Un petit script Python exécutable qui prend une URL de produit, récupère la page rendue via l'API Crawling sous forme de markdown propre, envoie ce markdown à Gemini avec un prompt d'extraction et écrit le résultat structuré dans un fichier JSON. Nous utiliserons une page de test publique pour que vous puissiez exécuter chaque extrait tel quel avant de le pointer sur une vraie cible.

Configurer l'environnement

Vous avez besoin de Python 3.8 ou version ultérieure. Confirmez votre version, créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les bibliothèques.

python --version

python -m venv gemini_env
source gemini_env/bin/activate

pip install google-generativeai crawlbase python-dotenv

Sous Windows, activez l'environnement avec gemini_env\Scripts\activate à la place de la ligne source. Trois dépendances font le travail : crawlbase est le client officiel pour l'API Crawling, google-generativeai est le client Gemini de Google, et python-dotenv charge vos clés depuis un fichier local pour qu'elles ne se retrouvent jamais codées en dur dans le script.

Vous avez besoin de deux identifiants. Obtenez une clé API Gemini depuis Google AI Studio, et obtenez un token JavaScript (JS) Crawlbase depuis votre tableau de bord Crawlbase après inscription. Stockez les deux dans un fichier .env dans votre dossier de projet.

GEMINI_API_KEY=your_gemini_key_here
CRAWLBASE_JS_TOKEN=your_crawlbase_js_token_here

Étape 1 : Récupérer la page rendue avec l'API Crawling

L'API Crawling peut renvoyer la page déjà convertie en markdown, ce qui est exactement ce que vous voulez avant de l'envoyer à un LLM. Le markdown supprime la navigation, les scripts et le bruit de style, ne laissant que le contenu lisible. Cela réduit le nombre de tokens que vous envoyez à Gemini, ce qui rend l'appel moins cher et l'extraction plus précise. Passez format: 'markdown' et l'API vous remet du texte propre plutôt que du HTML brut.

import os
from dotenv import load_dotenv
from crawlbase import CrawlingAPI

load_dotenv()

api = CrawlingAPI({"token": os.environ["CRAWLBASE_JS_TOKEN"]})

url = "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"

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

page_markdown = fetch_markdown(url)
print(page_markdown[:500])

Les deux options d'attente sont importantes pour les cibles rendues côté client. ajax_wait demande à l'API d'attendre que le contenu asynchrone ait fini de se charger, et page_wait maintient un délai fixe en millisecondes après le chargement pour que les éléments à rendu tardif apparaissent avant la capture de la page. Trois secondes est un bon point de départ ; augmentez si le contenu revient incomplet. Pour une page statique comme le livre de test ci-dessus, vous pourriez même utiliser le token normal, mais garder le token JS et ces options signifie que le même code fonctionne quand vous le pointez sur un site plus difficile, rendu côté client.

Étape 2 : Envoyer le contenu à Gemini et demander du JSON

Maintenant la partie intéressante. Avec du markdown propre en main, vous décrivez les champs souhaités dans un prompt et laissez Gemini faire l'extraction. L'astuce clé pour un pipeline fiable est de forcer la sortie JSON. Le client de Gemini prend en charge un type MIME de réponse, définissez-le sur application/json et le modèle renvoie du JSON analysable plutôt que de la prose avec des délimiteurs de code autour. Ce seul paramètre supprime la plupart de l'instabilité dont les gens se plaignent avec l'extraction par LLM.

import google.generativeai as genai

genai.configure(api_key=os.environ["GEMINI_API_KEY"])

model = genai.GenerativeModel("gemini-2.0-flash")

def extract_fields(content):
    prompt = f"""You are a data extraction tool. From the page content below,
extract the book title, price, availability, and star rating.
Return only JSON with keys: title, price, availability, rating.

CONTENT:
{content}
"""
    response = model.generate_content(
        prompt,
        generation_config={"response_mime_type": "application/json"},
    )
    return response.text

raw_json = extract_fields(page_markdown)
print(raw_json)

Plusieurs éléments font fonctionner ce prompt. Il définit le rôle ("data extraction tool") pour que Gemini reste concis, il nomme les clés exactes souhaitées pour que le schéma soit stable entre les exécutions, et il transmet le markdown plutôt que le HTML brut pour que le modèle concentre son attention sur le contenu, pas les éléments répétitifs. Si vous avez besoin d'un schéma plus riche, listez plus de clés et décrivez celles qui sont ambiguës ; le modèle gère les objets imbriqués et les tableaux sans cérémonie supplémentaire.

Étape 3 : Analyser et sauvegarder le résultat structuré

Comme vous avez demandé un type MIME JSON, le texte de réponse est déjà du JSON valide. Analysez-le en dictionnaire Python et écrivez-le sur le disque. Encapsulez l'analyse dans un try/except pour qu'une rare réponse malformée journalise le texte brut plutôt que de faire planter l'exécution.

import json

def save_json(raw, path="book_data.json"):
    try:
        data = json.loads(raw)
    except json.JSONDecodeError:
        print("Gemini did not return valid JSON:")
        print(raw)
        return
    with open(path, "w") as f:
        json.dump(data, f, indent=2)
    print(f"Saved {path}")

save_json(raw_json)

Le script complet

Voici tout assemblé en un fichier exécutable. Remplissez vos deux identifiants dans .env, changez l'URL et ajustez les clés du prompt pour la cible que vous extrayez.

import os
import json
from dotenv import load_dotenv
from crawlbase import CrawlingAPI
import google.generativeai as genai

load_dotenv()
api = CrawlingAPI({"token": os.environ["CRAWLBASE_JS_TOKEN"]})
genai.configure(api_key=os.environ["GEMINI_API_KEY"])
model = genai.GenerativeModel("gemini-2.0-flash")

url = "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"

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

def extract_fields(content):
    prompt = f"""You are a data extraction tool. From the page content below,
extract the book title, price, availability, and star rating.
Return only JSON with keys: title, price, availability, rating.

CONTENT:
{content}
"""
    response = model.generate_content(
        prompt,
        generation_config={"response_mime_type": "application/json"},
    )
    return response.text

def main():
    markdown = fetch_markdown(url)
    raw = extract_fields(markdown)
    try:
        data = json.loads(raw)
    except json.JSONDecodeError:
        print("Gemini did not return valid JSON:", raw)
        return
    with open("book_data.json", "w") as f:
        json.dump(data, f, indent=2)
    print(json.dumps(data, indent=2))

if __name__ == "__main__":
    main()

À quoi ressemble la sortie

Exécutez-le avec python scraper.py et vous obtenez des données structurées propres écrites dans book_data.json et affichées dans la console.

{
  "title": "A Light in the Attic",
  "price": "£51.77",
  "availability": "In stock (22 available)",
  "rating": "Three"
}

Notez ce que vous n'avez pas écrit : aucun sélecteur CSS, aucun XPath, aucune logique d'analyse par champ. Vous avez décrit les champs et le modèle les a trouvés. Pointez le même script sur une URL de livre différente, ou une page produit sur un autre site, et il s'adapte sans modifications de code, ce qui est le vrai avantage de l'approche d'extraction de données par IA par rapport aux sélecteurs réglés à la main.

Passer à l'échelle avec de nombreuses pages

Une page est une démonstration ; un vrai travail s'exécute sur une liste d'URLs. La forme reste la même : boulez les URLs, récupérez chacune via l'API Crawling, extrayez avec Gemini et collectez les lignes. Deux choses à garder en tête lors du passage à l'échelle. Gemini facture par token, donc envoyer du markdown plutôt que du HTML complet réduit le coût à chaque appel, et l'API Crawling a son propre débit pour que vous n'ayez pas à gérer vous-même des proxies ou des instances de navigateur.

urls = [
    "https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html",
    "https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html",
]

results = []
for u in urls:
    markdown = fetch_markdown(u)
    raw = extract_fields(markdown)
    try:
        results.append(json.loads(raw))
    except json.JSONDecodeError:
        print(f"Skipped {u}: invalid JSON")

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

Si vous vous retrouvez à extraire le même site bien connu encore et encore (Amazon, un grand détaillant, un site d'offres d'emploi), il vaut la peine de comparer cela avec la Crawling API, qui renvoie du JSON pré-analysé pour les sites pris en charge sans LLM dans la boucle. Pour les mises en page inhabituelles ou ponctuelles où aucun parseur n'existe, l'approche Gemini de ce guide est le recours flexible. Pour des informations générales sur pourquoi le markdown est la bonne forme d'entrée pour un LLM, consultez le markdown prêt pour les LLMs pour le web scraping.

Limites à connaître avant de déployer

Le pipeline Gemini plus Crawlbase est flexible, mais ce n'est pas le bon outil pour chaque situation. Gardez ces points en tête.

Le coût en tokens s'accumule. Gemini facture par token envoyé et reçu. Envoyer du HTML complet plutôt que du markdown peut multiplier votre facture sans bénéfice, donc réduisez toujours l'entrée. Pour les très grandes pages, extrayez uniquement la section pertinente avant l'appel au LLM.

C'est plus lent que l'analyse basée sur des règles. Un aller-retour LLM prend plus de temps qu'un sélecteur Cheerio ou BeautifulSoup. Pour les travaux à haute fréquence et faible latence comme la surveillance des prix à la seconde, un parseur dédié l'emporte. L'approche LLM brille quand les mises en page varient ou changent souvent.

Les modèles peuvent se tromper. Sur des pages denses ou répétitives, un modèle peut occasionnellement mal étiqueter ou manquer un champ. Forcer la sortie JSON et nommer des clés exactes réduit beaucoup cela, mais pour tout ce qui est critique, validez le dictionnaire analysé contre un schéma attendu avant de lui faire confiance.

Pour rester débloqué à volume, l'API Crawling gère la rotation d'IP et le rendu pour vous. Si vous préférez router votre propre trafic via un pool rotatif, le Smart AI Proxy (aussi appelé AI Proxy) vous donne la même rotation d'IP résidentielle comme point d'extrémité proxy drop-in. Dans tous les cas, le guide pratique complet se trouve dans comment scraper des sites sans être bloqué.

Foire aux questions

Gemini peut-il faire du web scraping seul ?

Pas la partie récupération. Gemini lit et structure le contenu que vous lui donnez, mais il n'a pas de client HTTP, de navigateur ni de pool de proxies, il ne peut donc pas ouvrir une URL ni passer les défenses anti-bot. Vous l'associez à une couche de récupération comme l'API Crawling, qui rend la page et renvoie du HTML propre ou du markdown ; Gemini extrait ensuite les champs structurés de ce contenu.

Pourquoi convertir la page en markdown avant de l'envoyer à Gemini ?

Le markdown supprime la navigation, les scripts et le bruit de style, ne laissant que le contenu lisible. Cela réduit le nombre de tokens envoyés à Gemini, ce qui réduit le coût et améliore la précision car le modèle concentre son attention sur le vrai contenu plutôt que sur les éléments répétitifs. L'API Crawling peut renvoyer directement du markdown avec format: 'markdown', vous n'avez donc pas besoin d'une étape de conversion séparée.

Ai-je besoin du token normal ou du token JS de Crawlbase ?

Utilisez le token JS pour toute page qui rend le contenu côté client, ce qui est le cas de la plupart des sites modernes. Le token normal récupère le HTML statique, donc sur une page rendue côté client il renvoie une coque vide et Gemini n'a rien à extraire. Le token JS rend d'abord la page dans un vrai navigateur, pour que le contenu soit présent quand il atteint le modèle.

Comment faire renvoyer du JSON fiable à Gemini plutôt que de la prose ?

Définissez response_mime_type de la configuration de génération sur application/json et nommez les clés exactes souhaitées dans le prompt. Cette combinaison fait renvoyer à Gemini du JSON analysable sans délimiteurs de code ni commentaires. Encapsulez quand même l'appel json.loads dans un try/except pour qu'une rare réponse malformée journalise le texte brut plutôt que de faire planter votre exécution.

L'approche Gemini est-elle meilleure que la Scraper API pour tout ?

Non, elles servent des besoins différents. Pour les sites bien connus avec des parseurs existants, la Scraper API renvoie du JSON pré-analysé plus rapidement et sans coût de tokens LLM. Le pipeline Gemini est le recours flexible pour les mises en page inhabituelles, ponctuelles ou qui changent fréquemment, où aucun parseur dédié n'existe et où vous préférez décrire les champs plutôt que maintenir des sélecteurs.

Est-ce que cela va me faire bloquer ?

L'API Crawling rend les pages derrière des IPs résidentielles rotatives côté serveur, ce qui gère la plupart des blocages pour vous. Si vous construisez votre propre stack de récupération, cette rotation est la partie dans laquelle investir, et vous pouvez utiliser le Smart AI Proxy comme point d'extrémité rotatif drop-in. Cadencez vos requêtes, variez vos cibles et surveillez les codes de statut pour pouvoir reculer dès qu'un site commence à défier le trafic.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.