Le web scraping avec Gemini qui fonctionne vraiment (code + sans code)

La plupart des tutoriels sur le "gemini web scraping" semblent écrits pour la même personne : un développeur Python qui a déjà configuré son environnement virtuel, un schéma Pydantic et une opinion bien arrêtée sur les bibliothèques async. Si c’est votre cas, parfait — on va parler code. Mais si vous travaillez dans la vente, le marketing ou les opérations ecommerce et que vous voulez simplement des données structurées à partir de plusieurs pages web sans apprendre ce que fait markdownify, vous n’êtes pas seul.

Gemini est la famille d’IA multimodale de Google, et elle devient rapidement l’un des moteurs de référence pour l’extraction de données web. Le Developer Survey 2025 de Stack Overflow montre que utilisent ou prévoient d’utiliser des outils d’IA — et le scraping piloté par des LLM fait partie intégrante de cette tendance. Mais il existe un vrai fossé entre une "démo sympa sur une seule URL" et un pipeline capable de gérer la pagination, les sous-pages, les protections anti-bot et un HTML sale à grande échelle. Ce guide couvre à la fois l’approche Python (code) et l’approche sans code, explique comment choisir un modèle avec de vrais calculs de tokens, aborde le scraping multi-page (l’étape que presque tous les autres tutoriels passent sous silence) et explique franchement où le scraping avec Gemini atteint ses limites. À la fin, vous saurez quelle option convient à votre workflow — et comment éviter les pièges qui font trébucher aussi bien les développeurs que les utilisateurs métiers.

Qu’est-ce que le web scraping avec Gemini ?

Le web scraping avec Gemini consiste à envoyer le contenu d’une page web — HTML, Markdown, ou même une capture d’écran — à l’un des modèles d’IA Gemini de Google, qui interprète ensuite la page et renvoie des données structurées. Pas de sélecteurs CSS. Pas de XPath. Pas de règles fragiles qui cassent dès qu’un site modifie son interface.

Le flux de travail de base ressemble à ceci :

1. Récupérer la page (avec requests, un navigateur headless ou une extension Chrome)
2. Nettoyer et convertir le contenu (souvent HTML → Markdown, pour réduire le coût en tokens)
3. Envoyer à Gemini avec un schéma décrivant les champs souhaités
4. Recevoir du JSON structuré prêt pour votre tableur, votre CRM ou votre base de données

Comparez cela au scraping traditionnel avec BeautifulSoup ou Selenium, où vous codez en dur des sélecteurs comme div.product-title > span.price en espérant que le site ne soit pas refondu mardi prochain. Gemini lit la page comme le ferait un humain : il comprend le contexte, s’adapte aux changements de mise en page et gère un formatage chaotique sans règles personnalisées.

Autre point important : Gemini est nativement multimodal. Il traite du texte, des images, de la vidéo, de l’audio, des PDF et du code dans une seule requête. Cela ouvre des approches de scraping — par exemple envoyer une capture d’écran au lieu du HTML — que la plupart des autres LLM ne peuvent tout simplement pas égaler. On y reviendra plus loin.

Pourquoi le web scraping avec Gemini est important pour les équipes métiers

Si vous vous demandez pourquoi un responsable marketing ou un analyste ecommerce devrait s’intéresser aux LLM et au scraping, la réponse tient en une phrase : cela fait gagner énormément de temps et cela casse beaucoup moins souvent quand un site change.

Le d’environ 1 milliard de dollars en 2025 à plus de 2 milliards en 2030 — et l’extraction pilotée par l’IA est le segment qui progresse le plus vite. Ce n’est pas du buzz : c’est le signe d’un vrai changement dans la façon dont les équipes collectent leurs données.

Voici comment le scraping avec Gemini s’intègre dans des workflows métiers courants :

L’avantage concret est double. D’abord, vous évitez la boucle éternelle qui consiste à écrire, tester et déboguer des scripts d’analyse — le modèle relit la page à neuf à chaque fois. Ensuite, vous n’avez plus besoin d’un développeur à chaque fois qu’un site déplace un <div>. Le niveau gratuit de Gemini rend l’expérimentation presque sans coût pour de petits volumes : , sans carte bancaire.

Quel modèle Gemini choisir ? (Flash Lite vs. Flash vs. Pro)

Tous les modèles Gemini ne se valent pas pour le scraping. Voici la comparaison pratique que j’aurais aimé voir dans tous les tutoriels, car choisir le mauvais niveau vous fait soit gaspiller de l’argent, soit produire des données inutilisables.

Les trois modèles Gemini 2.5 actuels partagent une fenêtre de contexte de 1 048 576 tokens et sont multimodaux. Les différences portent sur le coût, la vitesse et la qualité sur les extractions complexes.

(Tarifs issus du . L’API Batch bénéficie d’une remise de 50 % sur ces tarifs.)

Gemini 2.5 Flash Lite : rapide et économique, mais attention aux trous

Flash Lite est l’option économique. Il est parfait pour des données simples et plates — noms de produits, prix, listes à un seul niveau — à gros volume. En revanche, il présente des problèmes documentés avec les champs facultatifs, les horodatages et les données imbriquées. Un développeur sur le forum de Google a que Flash Lite "part en vrille" quand le schéma contient des propriétés non obligatoires, allant jusqu’à générer du texte répétitif jusqu’à atteindre la limite de tokens. Si votre schéma contient plus de deux niveaux d’imbrication, ou des champs parfois absents, Flash Lite risque de brûler vos tokens et votre patience.

Gemini 2.5 Flash : le meilleur compromis pour la plupart des projets

Flash est, selon moi, le point de départ pour presque toute tâche de scraping sérieuse. Il gère bien l’extraction structurée, sait traiter la logique de pagination et coûte environ 3 fois plus cher que Flash Lite en entrée — mais le gain en précision vaut largement le surcoût. Sur les benchmarks de raisonnement de niveau , Flash se rapproche de Pro à quelques points près, ce qui signifie qu’il gère correctement l’inférence, la normalisation et l’aplatissement dont le scraping a réellement besoin.

Gemini 2.5 Pro : la précision maximale pour les données complexes

Pro est l’outil de précision. Utilisez-le lorsque vous extrayez des schémas profondément imbriqués (par exemple : des fiches produits avec plusieurs groupes de variantes, chacun avec tailles, couleurs et prix), ou lorsque toute donnée inventée est inacceptable (juridique, financier, médical). Son coût d’entrée est environ 12 fois supérieur à Flash Lite, donc réservez-le aux cas où la précision compte plus que le prix.

Exemple de coût concret : 10 000 pages produit

En supposant que vous prétraitiez le HTML en Markdown (ce qu’il faut faire — nous y revenons juste après), une page produit typique passe d’environ 20 000 tokens de HTML brut à environ 4 000 tokens en Markdown. Le JSON de sortie représente environ 500 tokens par page.

Sans prétraitement Markdown (HTML brut à ~200M tokens en entrée), ces chiffres explosent de 4 à 5 fois. Le prétraitement est l’optimisation la plus rentable de tout le pipeline.

Code ou sans code : deux chemins pour le web scraping avec Gemini

Voici le moment du choix. Si vous êtes développeur et que vous construisez un pipeline personnalisé, la voie Python + API Gemini vous donne un contrôle maximal. Si vous êtes un utilisateur métier qui a besoin de données tout de suite et ne veut pas toucher un terminal, un scraper IA sans code vous fait gagner du temps.

est l’option sans code que nous avons développée chez Thunderbit — une extension Chrome qui utilise l’IA (notamment Gemini, ChatGPT, Claude et d’autres en arrière-plan) pour suggérer les champs, scraper en deux clics et exporter vers l’outil de votre choix. Je présenterai les deux approches ci-dessous.

Pour les utilisateurs qui travaillent d’abord dans un tableur, Quadratic est une autre option intéressante : c’est un tableur IA capable d’exécuter du web scraping alimenté par Gemini directement dans la feuille. Mais pour les workflows qui partent d’une page web connue (listes produits, annuaires, bases de leads), Thunderbit correspond davantage au modèle mental de l’utilisateur.

Étape par étape : web scraping avec Gemini en Python

Cette partie s’adresse aux développeurs. Si vous voulez la solution sans code, passez à la suite.

Avant de commencer :

• Niveau : intermédiaire (des bases en Python sont nécessaires)
• Temps requis : ~20–30 minutes pour le premier scraping
• Ce qu’il vous faut : Python 3.10+, un compte Google AI Studio (gratuit), une URL cible

Étape 1 : configurer l’environnement Python et la clé API Gemini

Créez un dossier projet et un environnement virtuel, puis installez les bibliothèques nécessaires :

1mkdir gemini-scraper && cd gemini-scraper
2python -m venv venv && source venv/bin/activate
3pip install -U google-genai requests beautifulsoup4 markdownify pydantic

Important : le seul SDK correct en 2026 est google-genai. L’ancien package google-generativeai a atteint sa fin de vie le 2025-11-30 et est désormais obsolète. Si vous voyez import google.generativeai as genai dans un tutoriel, ce code n’est plus à jour.

Ensuite, récupérez votre clé API dans . Cliquez sur "Get API Key", créez une nouvelle clé et stockez-la comme variable d’environnement :

1export GEMINI_API_KEY="your-key-here"

Vous devez maintenant disposer d’un environnement Python fonctionnel avec toutes les dépendances installées et votre clé API prête.

Étape 2 : récupérer le HTML de la page cible

Utilisez requests pour récupérer la page. Pour cet exemple, imaginons que nous scrapions une page produit :

1import requests
2url = "https://example.com/product/widget-pro"
3response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"}, timeout=30)
4html = response.text

Si le site repose fortement sur JavaScript ou utilise une protection anti-bot, requests.get() peut renvoyer une coquille vide ou un code 403. Nous verrons les solutions dans la section sur les limites — mais pour beaucoup de sites publics, cela fonctionne très bien.

Étape 3 : nettoyer le HTML et le convertir en Markdown

C’est l’étape que la plupart des tutoriels mentionnent sans jamais la quantifier. Un HTML brut de page produit pèse souvent autour de 20 000 tokens. Après un nettoyage avec BeautifulSoup et une conversion en Markdown, on descend à environ 765–4 000 tokens — soit une qui économise réellement de l’argent et réduit les hallucinations.

1from bs4 import BeautifulSoup
2from markdownify import markdownify
3soup = BeautifulSoup(html, "html.parser")
4main = soup.select_one("main") or soup  # ne garder que la zone de contenu
5markdown_content = markdownify(str(main))

L’appel select_one("main") supprime les en-têtes, pieds de page, barres de navigation et scripts — tout ce bruit qui gaspille des tokens et perturbe le modèle. Si le site n’utilise pas de balise <main>, essayez .product-detail, #content, ou tout autre conteneur qui englobe les données réelles.

À ce stade, vous devez obtenir une chaîne Markdown propre contenant uniquement le contenu utile de la page.

Étape 4 : définir le schéma de données et envoyer la requête à Gemini

Utilisez Pydantic pour définir ce que vous voulez récupérer. Le SDK google-genai accepte directement un BaseModel Pydantic comme response_schema :

1from google import genai
2from google.genai import types
3from pydantic import BaseModel
4class Product(BaseModel):
5    name: str
6    price: str
7    sku: str | None = None
8    description: str
9    sizes: list[str] = []
10    colors: list[str] = []
11client = genai.Client()  # lit GEMINI_API_KEY depuis l’environnement
12response = client.models.generate_content(
13    model="gemini-2.5-flash",
14    contents=f"Extract product details from this page:\n\n{markdown_content}",
15    config=types.GenerateContentConfig(
16        response_mime_type="application/json",
17        response_schema=Product,
18    ),
19)
20product = response.parsed
21print(product)

Quelques pièges tirés du :

• N’utilisez pas Field(default=...) dans les schémas envoyés à Gemini — l’API renvoie une erreur ValueError. Déclarez plutôt sku: str | None = None directement au niveau du type.
• Gardez une structure peu profonde (3 niveaux max). Les schémas trop imbriqués provoquent, sur Flash et Flash Lite, des sorties récursives ou des crochets non fermés.
• Marquez les champs comme requis avec Flash Lite, et utilisez des chaînes vides sentinelles plutôt que l’omission — la gestion des champs optionnels par Flash Lite est .

Vous devriez maintenant disposer d’un objet Product analysé avec des données structurées extraites de la page.

Étape 5 : exporter et stocker les données extraites

Enregistrez le résultat en JSON ou CSV :

1import json
2with open("products.json", "w") as f:
3    json.dump(product.model_dump(), f, indent=2)

Pour l’envoyer dans Google Sheets, vous pouvez utiliser la bibliothèque gspread. Pour une base de données, sérialisez les données vers l’ORM de votre choix. La sortie structurée de Gemini est suffisamment propre pour être injectée directement dans la plupart des outils en aval.

Étape par étape : web scraping avec Gemini sans code (avec Thunderbit)

Voici l’option idéale pour les utilisateurs métiers — ou pour les développeurs qui ne veulent pas écrire de scripts de scraping jetables.

Avant de commencer :

• Niveau : débutant
• Temps requis : ~5 minutes pour le premier scraping
• Ce qu’il vous faut : navigateur Chrome, (le niveau gratuit suffit)

Étape 1 : installer l’extension Chrome Thunderbit

Rendez-vous sur le et cliquez sur "Add to Chrome". Inscrivez-vous avec votre adresse e-mail — tout le processus prend moins d’une minute. Comparez cela aux 15–30 minutes nécessaires pour la configuration Python ci-dessus.

Étape 2 : ouvrir la page cible et cliquer sur "AI Suggest Fields"

Accédez au site que vous voulez scraper — une liste de produits, un annuaire immobilier, une base de leads, peu importe. Cliquez sur l’icône Thunderbit dans la barre d’outils du navigateur, puis sur "AI Suggest Fields".

L’IA de Thunderbit lit la page et recommande automatiquement les noms de colonnes et les types de données — par exemple "Product Name", "Price", "Rating", "Image URL". Vous pouvez ajuster les noms de colonnes, supprimer les champs inutiles ou ajouter des invites IA personnalisées par colonne (par exemple : "classer en High/Medium/Low" ou "traduire en anglais").

Vous devez voir un aperçu du tableau avec les colonnes configurées avant même d’extraire une seule ligne.

Étape 3 : cliquer sur "Scrape" et vérifier les résultats

Un clic. Thunderbit gère la pagination — qu’il s’agisse de boutons "Next" ou du scroll infini — et extrait les données dans un tableau structuré. Vous pouvez choisir entre :

• Cloud Scraping : plus rapide, traite jusqu’à 50 pages en parallèle. Fonctionne sur les sites publics.
• Browser Scraping : fonctionne dans l’onglet de votre navigateur déjà connecté. À utiliser pour les sites nécessitant une authentification (CRM, annuaires protégés, outils internes).

Les résultats apparaissent dans un tableau directement dans la barre latérale de l’extension. Vérifiez les erreurs évidentes avant l’export.

Étape 4 : exporter vers Excel, Google Sheets, Airtable ou Notion

Cliquez sur le bouton d’export et choisissez votre format. Thunderbit exporte vers Excel, Google Sheets, Airtable et Notion — gratuitement, sans mur payant. Les champs image sont envoyés directement dans les bibliothèques d’images de Notion et Airtable, ce qui est pratique si vous extrayez des photos de produits ou des portraits.

Pas d’analyse JSON. Pas de script. Les données sont immédiatement exploitables.

Scraping multi-pages et sous-pages avec Gemini

La plupart des tutoriels s’arrêtent discrètement après une seule URL. Les vrais projets de scraping, eux, ne s’arrêtent pas.

Scraper 500 pages produit avec pagination et sous-pages de détail est un vrai chantier — et l’écart entre une démo sur une URL et cette réalité est immense.

Gérer la pagination avec l’API Gemini (approche code)

Pour des URL paginées par numéro (le cas le plus courant), bouclez sur les pages jusqu’à obtenir un résultat vide :

1import time
2all_products = []
3for page in range(1, 101):  # jusqu'à 100 pages
4    url = f"https://example.com/products?page={page}"
5    md = fetch_clean(url)  # votre fonction HTML→Markdown vue plus haut
6    response = client.models.generate_content(
7        model="gemini-2.5-flash-lite",  # économique pour les pages de liste
8        contents=f"Extract product names and URLs:\n\n{md}",
9        config=types.GenerateContentConfig(
10            response_mime_type="application/json",
11            response_schema=list[ListingItem],
12        ),
13    )
14    items = response.parsed
15    if not items:
16        break
17    all_products.extend(items)
18    time.sleep(4)  # respecter les limites du niveau gratuit

Pour les sites à curseur ou à scroll infini, vous devrez intercepter l’endpoint XHR appelé par le front-end (vérifiez l’onglet Network de votre navigateur) et boucler directement sur cet endpoint. C’est moins coûteux que de re-render toute la page, et vous n’envoyez les éléments à Gemini que si des champs nécessitent un nettoyage par LLM.

Surveillez bien vos coûts en tokens ici — chaque page multiplie la facture. Utilisez Flash Lite pour les pages de liste simples et ne passez à Flash que pour l’extraction détaillée.

Scraper des sous-pages pour enrichir les données (approche code)

Le schéma classique en deux étapes : l’étape 1 extrait les URL depuis une page liste, l’étape 2 visite chaque page détail pour récupérer des informations plus riches.

1# Étape 1 : collecter les URLs avec le Flash Lite économique
2class Listing(BaseModel):
3    product_urls: list[str]
4listing = client.models.generate_content(
5    model="gemini-2.5-flash-lite",
6    contents=f"Extract product URLs:\n{listing_md}",
7    config=types.GenerateContentConfig(
8        response_mime_type="application/json",
9        response_schema=Listing,
10    ),
11).parsed
12# Étape 2 : extraire les détails avec Flash
13class ProductDetail(BaseModel):
14    name: str
15    price: str
16    specs: dict[str, str]
17    reviews: list[str]
18for url in listing.product_urls:
19    md = fetch_clean(url)
20    detail = client.models.generate_content(
21        model="gemini-2.5-flash",
22        contents=f"Extract product detail:\n{md}",
23        config=types.GenerateContentConfig(
24            response_mime_type="application/json",
25            response_schema=ProductDetail,
26        ),
27    ).parsed
28    # sauvegarder le détail...
29    time.sleep(0.5)

Cela fonctionne, mais demande beaucoup d’infrastructure : déduplication des URLs, gestion des erreurs, limitation du débit, logique de retry, cache du HTML brut pour ne pas relancer les requêtes à chaque ajustement du schéma. Pour 50 pages, c’est gérable. Pour 5 000, vous êtes en train de construire une plateforme.

L’alternative sans code : la pagination et les sous-pages intégrées de Thunderbit

Thunderbit gère automatiquement la pagination par clic et le scroll infini — pas besoin d’écrire de boucle. Pour enrichir les sous-pages, la fonction "Scrape Subpages" visite chaque page de détail liée depuis votre liste et enrichit le tableau d’origine avec des champs plus profonds. Un clic, pas un script.

Le mode Cloud Scraping traite jusqu’à 50 pages simultanément, ce qui change vraiment la donne lorsque vous scrapez un catalogue produits ou un annuaire immobilier à grande échelle. Pour toute personne qui ne veut pas gérer des boucles Python et de la logique de retry, c’est le choix le plus pratique. (Pour aller plus loin sur , nous avons un guide dédié.)

Scraping par capture d’écran : le raccourci multimodal de Gemini

Voici une approche que la plupart des tutoriels ignorent complètement : envoyer une capture d’écran d’une page web à l’API vision de Gemini au lieu du HTML brut. Un développeur a qu’une seule capture d’écran ne coûte qu’environ 258 tokens — contre des milliers même pour du Markdown nettoyé. La différence de coût est énorme pour des extractions simples.

Comment utiliser l’API Vision de Gemini pour le web scraping

Prenez une capture d’écran avec Playwright, encodez-la et envoyez-la à Gemini :

1from playwright.sync_api import sync_playwright
2from google import genai
3from google.genai import types
4from pydantic import BaseModel
5class Product(BaseModel):
6    title: str
7    price: str
8with sync_playwright() as p:
9    page = p.chromium.launch().new_page()
10    page.goto("https://example.com/product/widget-pro")
11    page.wait_for_load_state("networkidle")
12    png_bytes = page.screenshot(full_page=False)  # uniquement la partie visible
13client = genai.Client()
14resp = client.models.generate_content(
15    model="gemini-2.5-flash",
16    contents=[
17        {"inline_data": {"mime_type": "image/png", "data": png_bytes}},
18        "Extract the product title and price as JSON.",
19    ],
20    config=types.GenerateContentConfig(
21        response_mime_type="application/json",
22        response_schema=Product,
23    ),
24)
25print(resp.parsed)

Selon la , une image dont les deux dimensions sont ≤ 384 pixels coûte 258 tokens. Les images plus grandes sont découpées en blocs de 768×768, à 258 tokens par bloc. Une capture courte visible à l’écran (258–1 600 tokens) est très avantageuse par rapport au HTML brut — mais une très longue capture plein écran (~5 000 tokens) peut en fait coûter plus cher qu’un Markdown propre (~765–1 200 tokens).

Limites du scraping par capture d’écran

• Précision plus faible pour les tableaux denses : les mises en page multi-colonnes, les petites polices et les éléments qui se chevauchent provoquent des lectures partielles — pas des hallucinations, mais des libellés manquants et des en-têtes mal alignés.
• Impossible de suivre les liens : la vision renvoie du texte, pas des ancres cliquables. Pas de pagination, pas d’enrichissement de sous-pages.
• Plafond de résolution : le texte inférieur à ~10 px est souvent mal lu. Google réduit l’image à environ 1 568 px sur le bord le plus long.
• Coût de capture : lancer Playwright + attendre networkidle prend 2 à 5 secondes par page, ce qui finit par peser à grande échelle.

Le scraping par capture d’écran est excellent pour les pages lourdes en JavaScript, les sites bloqués par les bots (quand requests.get() renvoie un 403 mais qu’un navigateur affiche la page correctement) et les pages contenant des données intégrées dans des graphiques ou des images. Pour les pages longues et textuelles, le Markdown reste la meilleure option.

Le scraping d’images et de PDF dans Thunderbit utilise une approche similaire basée sur la vision IA — il suffit de déposer une image ou un PDF et d’obtenir un tableau structuré, sans script de capture ni manipulation de base64. (Voir aussi : .)

Quand le web scraping avec Gemini échoue (et quoi faire à la place)

Gemini est un moteur d’extraction, pas un moteur de récupération. Si vous ne pouvez pas obtenir le contenu de la page pour Gemini, il ne pourra rien faire. Point.

Il existe plusieurs scénarios fréquents où toute l’approche se bloque, et la plupart des tutoriels les traitent comme un détail secondaire. Je préfère être clair.

Quelques-uns de ces points méritent un peu de contexte.

L’anti-bot est désormais activement sensible aux LLM. Cloudflare depuis juillet 2025, avec 416 milliards de requêtes de bots IA bloquées au cours des cinq premiers mois. Datadome a ajouté en 2025 une détection spécifique aux LLM et a vu le trafic des bots LLM quadrupler. Un simple requests.get() + Gemini est pratiquement condamné sur les sites protégés par Datadome. Le problème, c’est l’empreinte technique, pas l’adresse IP — changer d’IP ne sert à rien si l’empreinte TLS crie "Python requests".

Les hallucinations sont subtiles. Les LLM entraînés pour être utiles remplissent volontiers des champs optionnels avec des fabrications plausibles plutôt que de renvoyer null. J’ai vu des modèles deviner la marque d’un produit à partir du slug d’URL, déduire la devise à partir du TLD et inventer des comptes d’avis crédibles à partir de skeleton loaders. L’arsenal de mitigation : schémas Pydantic stricts, boucles de retry avec feedback de validation, validateurs de grounding qui vérifient que les valeurs extraites apparaissent bien dans le HTML source, et (Flash extrait, Pro valide un échantillon).

La fenêtre de contexte de 1M n’est pas exploitable à 1M. Des et d’autres montrent que la qualité du raisonnement se dégrade bien avant la limite théorique. Considérez plutôt ~200K–300K tokens comme plafond pratique pour une extraction structurée.

Arbre de décision : quel outil choisir ?

• Faible volume + pages simples + développeur → niveau gratuit Gemini API + Python
• Volume moyen + schémas complexes + développeur → Gemini 2.5 Flash payant + Python + sorties structurées + prétraitement
• Quel que soit le volume + non-développeur + login ou pagination lourde →
• Très gros volume + anti-bot fort + mission critique → infrastructure de scraping gérée (services proxy) + Gemini comme couche d’extraction

Web scraping avec Gemini : conseils pour gagner du temps et de l’argent

Que vous écriviez du Python ou que vous cliquiez sur des boutons, ces conseils vous éviteront bien des ennuis.

1. Prétraitez toujours le HTML en Markdown avant de l’envoyer à Gemini. Une est courante ; 95 % sont possibles si vous éliminez aussi les éléments inutiles avec BeautifulSoup.
2. N’utilisez que google-genai. N’utilisez pas le package obsolète google-generativeai — il est en fin de vie.
3. Commencez avec Flash Lite uniquement pour des schémas plats. Passez à Flash dès que des champs imbriqués ou optionnels apparaissent.
4. Évitez Field(default=...) dans les schémas Pydantic que vous envoyez à Gemini. Déclarez plutôt sku: str | None = None au niveau du type.
5. Pydantic + response_schema sont essentiels — c’est à la fois un contrat et une barrière contre les hallucinations.
6. Utilisez l’ pour les jobs de plus de 1 000 pages — 50 % de remise et pas de consommation du quota RPM temps réel.
7. Validez manuellement un échantillon aléatoire de 10 à 50 lignes avant de passer à grande échelle avec un nouvel extracteur. Les dérives de précision sont invisibles tant qu’on ne vérifie pas.
8. Mettez en cache le HTML brut sur disque — un changement de schéma ne doit pas obliger à refaire les requêtes.
9. Enregistrez l’URL source sur chaque ligne pour pouvoir re-crawler des pages individuelles sans relancer tout le traitement.
10. Pour les utilisateurs sans code : utilisez les invites IA personnalisées par colonne dans Thunderbit pour déplacer l’ingénierie de prompt au niveau du tableur — traduire, catégoriser, résumer, tout cela par colonne.

Et un dernier conseil : ne déployez pas le niveau gratuit en production. Les limites ont été réduites de 50 à 80 % en décembre 2025 et pourraient l’être à nouveau sans préavis.

Conclusion

L’écart entre une démonstration Gemini sur une seule URL et un pipeline de production est bien plus grand que ne le laissent croire la plupart des tutoriels.

La voie Python + API Gemini donne aux développeurs un contrôle total sur le choix du modèle, le prétraitement, la pagination et la conception du schéma. La voie sans code — avec des outils comme — permet aux utilisateurs métiers d’obtenir la même extraction de données structurées sans ouvrir un terminal.

Voici les idées essentielles à retenir :

• Le choix du modèle compte. Flash Lite pour le volume, Flash pour l’équilibre, Pro pour la complexité. Ne choisissez pas systématiquement l’option la moins chère en vous demandant ensuite pourquoi vos données sont fausses.
• Le scraping multi-page et des sous-pages est le point faible de la plupart des tutoriels — et pourtant c’est là que se trouve le vrai travail. Les deux approches présentées ici comblent cette lacune.
• Des limites assumées vous font gagner du temps. Si un site bloque les requêtes API, aucune ingénierie de prompt ne vous sauvera. Choisissez le bon outil pour le bon travail, pas le plus sophistiqué.
• Le prétraitement HTML → Markdown est l’optimisation la plus rentable — il réduit les coûts de plus de 75 % et diminue les hallucinations.

Si vous voulez essayer l’approche sans code, le vous permet de scraper quelques pages et de voir le résultat par vous-même. Si vous préférez coder, le niveau gratuit de l’API Gemini suffit pour prototyper un pipeline en une après-midi. Dans les deux cas, vous obtiendrez des données structurées bien plus vite qu’avec du copier-coller manuel. Pour en savoir plus sur ou sur , nous avons déjà couvert ces sujets en détail sur notre blog.

FAQ

Combien coûte l’utilisation de Gemini pour le web scraping ?

L’API Gemini propose un niveau gratuit d’environ 100 requêtes/jour sur Pro, 500/jour sur Flash et 1 000/jour sur Flash Lite (début 2026 — ces limites ont été réduites en décembre 2025). Sur l’offre payante, le scraping de 10 000 pages produit coûte environ 1,50 $ avec Flash Lite, 6 $ avec Flash ou 25 $ avec Pro — à condition de prétraiter d’abord le HTML en Markdown. Sans prétraitement, les coûts sont multipliés par 4 à 5. L’API Batch offre une remise de 50 % pour les jobs non temps réel.

Gemini peut-il scraper des sites qui nécessitent une connexion ?

L’API Gemini seule ne peut pas se connecter à un site — elle ne traite que le contenu que vous lui envoyez. Vous devez récupérer le HTML vous-même via votre propre session authentifiée (par exemple avec un navigateur headless et des cookies enregistrés). Le mode Browser Scraping de Thunderbit gère cela nativement : il fonctionne dans votre onglet Chrome connecté, donc tout site visible dans votre navigateur peut être scrapé par Thunderbit.

Le web scraping avec Gemini est-il légal ?

La légalité dépend des conditions d’utilisation du site, du type de données et de votre juridiction. Aux États-Unis, après hiQ v. LinkedIn et Meta v. Bright Data, l’extraction de données publiques sans connexion est généralement considérée comme permise — mais chaque cas dépend de ses faits. Le scraping derrière une connexion comporte davantage de risques juridiques. Les données personnelles des résidents de l’UE sont soumises au RGPD, que le site soit public ou non. Respectez toujours robots.txt et les conditions d’utilisation, et évitez de scraper des données personnelles sans base légale.

Puis-je utiliser Gemini pour scraper des sites dynamiques lourds en JavaScript ?

Oui, mais il faut d’abord rendre le JavaScript — soit avec un navigateur headless (Playwright, Puppeteer), soit en interceptant directement les endpoints API du site. Une fois le HTML rendu obtenu, nettoyez-le et envoyez-le à Gemini comme d’habitude. Autre option : le scraping par capture d’écran avec l’API vision de Gemini contourne totalement le rendu JS — si le contenu s’affiche dans un navigateur, Gemini peut le voir. Thunderbit gère automatiquement les pages rendues en JavaScript, aussi bien en mode Cloud qu’en mode Browser.

Quelle est la différence entre utiliser Gemini pour le scraping et utiliser un outil dédié comme Thunderbit ?

Gemini est un moteur d’extraction : il interprète le contenu et renvoie des données structurées. Il ne visite pas les sites, ne gère pas la pagination, n’assure pas l’authentification et n’exporte pas vers des tableurs. Vous avez toujours besoin d’un outil pour amener le contenu de la page jusqu’à Gemini et d’un autre pour exploiter le résultat. Les outils dédiés comme combinent récupération, rendu, extraction IA, pagination, enrichissement des sous-pages et export dans un seul produit — sans plomberie technique.

En savoir plus