Scraper des avis Google Maps avec Python : Guide 2025

Si vous souhaitez scraper les avis Google Maps avec Python, vous faites face à l'un des cibles de scraping les plus délicates sur le web. Google charge les avis de manière dynamique, fait tourner sa structure HTML et détecte activement les bots. Ce guide couvre deux méthodes fonctionnelles — Playwright et Selenium — avec un code complet, des techniques anti-détection et des notes honnêtes sur ce qui casse et pourquoi.

Pas de blabla. Juste du code qui fonctionne.

---

Qu'est-ce que le scraping des avis Google ?

Le scraping des avis Google est l'extraction automatisée des données d'avis clients à partir de Google Maps et des fiches Google Business. Au lieu de copier manuellement les avis, un script visite les pages des entreprises et extrait les données pour vous.

Chaque avis contient des champs utiles :

• Évaluation par étoiles (1–5)
• Texte de l'avis
• Nom de l'évaluateur
• Date de publication
• Réponse de l'entreprise (le cas échéant)

Ces données ont une réelle valeur. La surveillance de la réputation, l'analyse concurrentielle, le suivi des sentiments, la qualification des leads — tout commence par des données d'avis brutes.

Pourquoi ne pas utiliser l'API officielle de Google ?

L'API Google Places vous donne des avis, mais avec des limites strictes. Vous obtenez au maximum 5 avis par entreprise. Pas de données historiques. Pas d'avis de concurrents. Les tarifs augmentent rapidement une fois que vous dépassez le niveau gratuit.

Le web scraping vous donne accès à tous les avis publics, sans plafond artificiel. Le compromis : vous devez gérer vous-même les systèmes anti-bot de Google.

---

Pourquoi Python pour cette tâche ?

Python a le meilleur écosystème pour l'automatisation des navigateurs et l'extraction de données. Trois bibliothèques font la plupart du travail :

• Playwright — moderne, rapide, prêt pour l'asynchrone, avec des fonctionnalités de furtivité intégrées
• Selenium — éprouvé, communauté massive, compatibilité maximale
• BeautifulSoup — léger pour l'analyse HTML une fois que vous avez le contenu brut

Les avis Google se chargent via JavaScript. Les scrapers statiques (requests + BeautifulSoup seuls) ne fonctionneront pas ici. Vous avez besoin d'un vrai navigateur qui exécute JS, fait défiler la page et clique sur des boutons — exactement ce que fait Playwright et Selenium.

---

Le défi principal : Pourquoi Google se défend

Avant d'écrire une seule ligne de code, comprenez à quoi vous êtes confronté.

Chargement de contenu dynamique

Google ne sert pas tous les avis dans le HTML initial. Le premier chargement de page montre 10–20 avis. D'autres se chargent au fur et à mesure que vous faites défiler. Chaque lot déclenche des requêtes réseau séparées. Votre scraper doit simuler le défilement pour déclencher ces chargements.

Couches de détection de bots

Google exécute plusieurs systèmes de détection simultanément :

• Empreinte du navigateur — résolution d'écran, polices, fuseau horaire, langue
• Analyse comportementale — modèles de mouvement de la souris, vitesse de défilement, timing des clics
• Reconnaissance des modèles de requêtes — fréquence des requêtes non humaines
• Réputation IP — signalement des IP qui envoient trop de requêtes

Franchissez l'un de ces déclencheurs et vous verrez des CAPTCHA, des résultats vides ou un blocage complet.

Structure HTML en constante évolution

Google met régulièrement à jour son frontend. Un sélecteur CSS qui fonctionne aujourd'hui peut ne rien retourner la semaine prochaine. Les scrapers robustes utilisent plusieurs sélecteurs de secours pour chaque champ.

---

Méthode 1 : Playwright (Recommandé pour 2025)

Playwright est le meilleur point de départ pour de nouveaux projets. Il est 2–3 fois plus rapide que Selenium, dispose d'un support asynchrone intégré et gère la détection anti-bot avec moins de configuration manuelle.

Configuration

python -m venv google_scraper_env
source google_scraper_env/bin/activate  # Windows : google_scraper_env\Scripts\activate
pip install playwright pandas emoji beautifulsoup4 lxml
playwright install chromium

Scraper Playwright complet

from playwright.sync_api import sync_playwright
import pandas as pd
import re
import emoji
import logging
import time
import random

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class GoogleReviewsScraper:
    def __init__(self, headless=True):
        self.headless = headless
        self.reviews_data = []

    def clean_text(self, text):
        text = emoji.replace_emoji(text, replace='')
        text = re.sub(r'\s+', ' ', text).strip()
        return text

    def random_delay(self, min_delay=1, max_delay=3):
        time.sleep(random.uniform(min_delay, max_delay))

    def initialize_browser(self):
        playwright = sync_playwright().start()
        browser = playwright.chromium.launch(
            headless=self.headless,
            args=[
                '--disable-blink-features=AutomationControlled',
                '--disable-extensions',
                '--no-sandbox',
                '--disable-setuid-sandbox',
                '--disable-dev-shm-usage',
                '--disable-gpu'
            ]
        )
        context = browser.new_context(
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            viewport={'width': 1366, 'height': 768}
        )
        page = context.new_page()
        page.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', {
                get: () => undefined,
            });
        """
        )
        return playwright, browser, page

    def search_business(self, page, business_name):
        try:
            page.goto("https://www.google.com/maps", wait_until="networkidle")
            self.random_delay(2, 4)
            search_box = page.locator("input[id='searchboxinput']")
            search_box.fill(business_name)
            search_box.press("Enter")
            page.wait_for_timeout(5000)
            logger.info(f"Searched for: {business_name}")
            return True
        except Exception as e:
            logger.error(f"Error searching: {e}")
            return False

    def navigate_to_reviews(self, page):
        try:
            reviews_tab = page.get_by_role("tab", name=re.compile("Reviews|reviews", re.IGNORECASE))
            if reviews_tab.is_visible():
                reviews_tab.click()
                page.wait_for_timeout(3000)
                logger.info("Navigated to reviews section")
                return True
            logger.warning("Reviews tab not found")
            return False
        except Exception as e:
            logger.error(f"Error navigating to reviews: {e}")
            return False

    def scroll_and_load_reviews(self, page, max_reviews=100):
        loaded_reviews = 0
        scroll_attempts = 0
        max_scroll_attempts = 20

        while loaded_reviews < max_reviews and scroll_attempts < max_scroll_attempts:
            try:
                page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
                self.random_delay(2, 4)
                current_reviews = page.locator('[data-review-id]').count()
                if current_reviews > loaded_reviews:
                    loaded_reviews = current_reviews
                    logger.info(f"Loaded {loaded_reviews} reviews...")
                    scroll_attempts = 0
                else:
                    scroll_attempts += 1
                try:
                    more_button = page.locator("button", has_text=re.compile("more|More", re.IGNORECASE))
                    if more_button.is_visible():
                        more_button.click()
                        self.random_delay(2, 3)
                except:
                    pass
            except Exception as e:
                logger.error(f"Error during scrolling: {e}")
                break

        logger.info(f"Total reviews found: {loaded_reviews}")
        return loaded_reviews

    def extract_review_data(self, page):
        reviews = []
        try:
            review_elements = page.locator('[data-review-id]').all()
            for element in review_elements:
                try:
                    review_data = {}

                    name_element = element.locator('div[class*="name"] span, div[class*="Name"] span').first
                    review_data['reviewer_name'] = name_element.inner_text() if name_element.is_visible() else "Anonymous"

                    rating_element = element.locator('[role="img"][aria-label*="star"]').first
                    if rating_element.is_visible():
                        rating_text = rating_element.get_attribute('aria-label')
                        rating_match = re.search(r'(\d+)', rating_text)
                        review_data['rating'] = int(rating_match.group(1)) if rating_match else None

                    text_elements = element.locator('span[class*="review-text"], div[class*="review-text"]').all()
                    review_text = ""
                    for text_elem in text_elements:
                        if text_elem.is_visible():
                            review_text += text_elem.inner_text() + " "
                    review_data['review_text'] = self.clean_text(review_text.strip())

                    date_element = element.locator('span[class*="date"], div[class*="date"]').first
                    review_data['review_date'] = date_element.inner_text() if date_element.is_visible() else "Unknown"

                    if review_data['review_text']:
                        reviews.append(review_data)
                except Exception as e:
                    logger.warning(f"Error on individual review: {e}")
                    continue

            logger.info(f"Extracted {len(reviews)} reviews")
            return reviews
        except Exception as e:
            logger.error(f"Extraction error: {e}")
            return []

    def scrape_reviews(self, business_name, max_reviews=100):
        playwright, browser, page = self.initialize_browser()
        try:
            if not self.search_business(page, business_name):
                return []
            if not self.navigate_to_reviews(page):
                return []
            self.scroll_and_load_reviews(page, max_reviews)
            reviews = self.extract_review_data(page)
            self.reviews_data = reviews
            return reviews
        except Exception as e:
            logger.error(f"Scraping failed: {e}")
            return []
        finally:
            browser.close()
            playwright.stop()

    def save_to_csv(self, filename="google_reviews.csv"):
        if self.reviews_data:
            df = pd.DataFrame(self.reviews_data)
            df.to_csv(filename, index=False, encoding='utf-8')
            logger.info(f"Saved to {filename}")
        else:
            logger.warning("No reviews to save")

if __name__ == "__main__":
    scraper = GoogleReviewsScraper(headless=False)
    business_name = "Starbucks Times Square New York"
    reviews = scraper.scrape_reviews(business_name, max_reviews=50)
    if reviews:
        scraper.save_to_csv(f"reviews_{business_name.replace(' ', '_')}.csv")
        print(f"Scraped {len(reviews)} reviews.")
    else:
        print("No reviews scraped.")

Ce que fait ce code

• Drapeaux de furtivité cachent l'empreinte d'automatisation de la couche de détection de Google
• Délai aléatoire entre 1–4 secondes imite le rythme de navigation humain
• Boucle de défilement continue de charger jusqu'à atteindre max_reviews ou jusqu'à épuisement du contenu
• Multiples sélecteurs de secours gèrent les changements fréquents de HTML de Google
• Export CSV vous donne un fichier propre prêt pour l'analyse ou l'importation dans n'importe quel outil

---

Méthode 2 : Selenium (Alternative fiable)

Selenium est la norme pour l'automatisation des navigateurs depuis plus d'une décennie. Il est plus lent que Playwright mais a une communauté plus large et plus de documentation.

Quand choisir Selenium

• Vous travaillez avec une infrastructure héritée qui l'utilise déjà
• Vous avez besoin de la compatibilité maximale entre les versions de navigateurs
• Votre équipe a une expertise existante en Selenium

Configuration

pip install selenium pandas

Vous aurez également besoin de ChromeDriver correspondant à votre version de Chrome. Le Selenium moderne (4.6+) gère automatiquement la gestion des pilotes.

Scraper Selenium complet

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.action_chains import ActionChains
from selenium.common.exceptions import TimeoutException, NoSuchElementException
import pandas as pd
import time
import random
import re
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class SeleniumGoogleReviewsScraper:
    def __init__(self, headless=True):
        self.headless = headless
        self.driver = None
        self.wait = None
        self.reviews_data = []

    def setup_driver(self):
        options = Options()
        if self.headless:
            options.add_argument("--headless")
        options.add_argument("--disable-blink-features=AutomationControlled")
        options.add_experimental_option("excludeSwitches", ["enable-automation"])
        options.add_experimental_option('useAutomationExtension', False)
        options.add_argument("--no-sandbox")
        options.add_argument("--disable-dev-shm-usage")
        options.add_argument("--window-size=1366,768")
        options.add_argument("--user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")

        self.driver = webdriver.Chrome(options=options)
        self.driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined,});")
        self.wait = WebDriverWait(self.driver, 20)
        logger.info("Driver initialized")

    def random_delay(self, min_s=1, max_s=3):
        time.sleep(random.uniform(min_s, max_s))

    def search_google_maps(self, business_name):
        try:
            self.driver.get("https://www.google.com/maps")
            self.random_delay(2, 4)
            search_box = self.wait.until(EC.presence_of_element_located((By.ID, "searchboxinput")))
            search_box.clear()
            for char in business_name:
                search_box.send_keys(char)
                time.sleep(random.uniform(0.05, 0.15))
            search_box.submit()
            self.wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "[data-value='Reviews']")))
            logger.info(f"Searched for: {business_name}")
            return True
        except TimeoutException:
            logger.error("Timeout on search")
            return False

    def click_reviews_tab(self):
        try:
            reviews_tab = self.wait.until(EC.element_to_be_clickable((By.CSS_SELECTOR, "[data-value='Reviews']")))
            self.driver.execute_script("arguments[0].scrollIntoView(true);")
            self.random_delay(1, 2)
            reviews_tab.click()
            self.wait.until(EC.presence_of_element_located((By.CSS_SELECTOR, "[data-review-id]")))
            logger.info("Reviews tab clicked")
            return True
        except TimeoutException:
            logger.error("Reviews tab not found")
            return False

    def scroll_to_load_reviews(self, target_reviews=100):
        last_height = self.driver.execute_script("return document.body.scrollHeight")
        reviews_loaded = 0
        scroll_attempts = 0

        while reviews_loaded < target_reviews and scroll_attempts < 30:
            self.driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
            self.random_delay(2, 4)
            try:
                show_more = self.driver.find_element(By.XPATH, "//button[contains(text(), 'more') or contains(text(), 'More')]\")
                if show_more.is_displayed():
                    ActionChains(self.driver).move_to_element(show_more).click().perform()
                    self.random_delay(2, 3)
            except NoSuchElementException:
                pass

            current_count = len(self.driver.find_elements(By.CSS_SELECTOR, "[data-review-id]"))
            if current_count > reviews_loaded:
                reviews_loaded = current_count
                logger.info(f"Loaded {reviews_loaded} reviews...")
                scroll_attempts = 0
            else:
                scroll_attempts += 1

            new_height = self.driver.execute_script("return document.body.scrollHeight")
            if new_height == last_height:
                scroll_attempts += 1
            last_height = new_height

        return reviews_loaded

    def extract_reviews(self):
        reviews = []
        review_elements = self.driver.find_elements(By.CSS_SELECTOR, "[data-review-id]")
        for element in review_elements:
            try:
                review_data = {}
                try:
                    review_data['reviewer_name'] = element.find_element(By.CSS_SELECTOR, "div[class*='name'] span").text.strip()
                except NoSuchElementException:
                    review_data['reviewer_name'] = "Anonymous"
                try:
                    aria_label = element.find_element(By.CSS_SELECTOR, "[role='img'][aria-label*='star']").get_attribute('aria-label')
                    match = re.search(r'(\d+)', aria_label)
                    review_data['rating'] = int(match.group(1)) if match else None
                except NoSuchElementException:
                    review_data['rating'] = None
                try:
                    text_elems = element.find_elements(By.CSS_SELECTOR, "span[class*='review-text']")
                    review_data['review_text'] = " ".join([e.text for e in text_elems if e.text]).strip()
                except NoSuchElementException:
                    review_data['review_text'] = ""
                try:
                    review_data['review_date'] = element.find_element(By.CSS_SELECTOR, "span[class*='date']").text.strip()
                except NoSuchElementException:
                    review_data['review_date'] = "Unknown"

                if review_data['review_text']:
                    reviews.append(review_data)
            except Exception as e:
                logger.warning(f"Review extraction error: {e}")
                continue

        logger.info(f"Extracted {len(reviews)} reviews")
        return reviews

    def scrape_business_reviews(self, business_name, max_reviews=100):
        try:
            self.setup_driver()
            if not self.search_google_maps(business_name):
                return []
            if not self.click_reviews_tab():
                return []
            self.scroll_to_load_reviews(max_reviews)
            reviews = self.extract_reviews()
            self.reviews_data = reviews
            return reviews
        except Exception as e:
            logger.error(f"Scraping failed: {e}")
            return []
        finally:
            if self.driver:
                self.driver.quit()

    def save_to_csv(self, filename="selenium_reviews.csv"):
        if self.reviews_data:
            pd.DataFrame(self.reviews_data).to_csv(filename, index=False, encoding='utf-8')
            logger.info(f"Saved to {filename}")

if __name__ == "__main__":
    scraper = SeleniumGoogleReviewsScraper(headless=False)
    reviews = scraper.scrape_business_reviews("McDonald's Times Square", max_reviews=75)
    if reviews:
        scraper.save_to_csv("mcdonalds_times_square_reviews.csv")
        print(f"Scraped {len(reviews)} reviews.")

---

Techniques anti-détection qui fonctionnent réellement

Les deux scrapers ci-dessus incluent des furtivités de base. Voici ce qu'il faut ajouter lorsque vous devez aller plus loin.

Rotation de proxy

Le scraping avec une seule IP est rapidement bloqué. Faites tourner les proxies pour distribuer les requêtes :

import random

PROXY_LIST = [
    "http://user:pass@proxy1:port",
    "http://user:pass@proxy2:port",
    "http://user:pass@proxy3:port",
]

def get_random_proxy():
    return random.choice(PROXY_LIST)

# Dans Playwright :
context = browser.new_context(proxy={"server": get_random_proxy()})

Les proxies résidentiels fonctionnent mieux que les proxies de centre de données pour Google spécifiquement. Les IP de centre de données sont signalées plus rapidement.

Rotation des agents utilisateurs

USER_AGENTS = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/120.0',
]

def get_random_ua():
    return random.choice(USER_AGENTS)

Typage humain

def human_type(element, text):
    for char in text:
        element.send_keys(char)
        time.sleep(random.uniform(0.05, 0.2))

Un typage à vitesse uniforme est un signal de bot. Des délais variables par caractère semblent humains.

Réchauffement de session

Ne vous dirigez pas directement vers Google Maps. Visitez d'abord Google Search, attendez quelques secondes, puis naviguez vers Maps. Les sessions froides qui sautent directement vers les cibles de scraping sont plus souvent signalées.

---

Gestion du contenu dynamique

Les avis Google utilisent un défilement infini — pas de numéros de page, pas de bouton "suivant". Votre scraper doit continuer à faire défiler jusqu'à ce que :

1. Il atteigne votre cible max_reviews, ou
2. Aucun nouvel avis ne se charge après plusieurs tentatives de défilement

Le code ci-dessus gère cela avec un compteur consecutive_failures. Après 5 défilements sans nouveaux avis, il s'arrête. C'est la bonne approche — ne bouclez pas indéfiniment.

Expansion des avis tronqués

Les longs avis sont coupés avec un lien "Plus". Pour obtenir le texte complet :

def expand_truncated_reviews(page):
    expand_buttons = page.locator("button:has-text('More'), span:has-text('...')")
    count = expand_buttons.count()
    for i in range(min(count, 100)):
        btn = expand_buttons.nth(i)
        if btn.is_visible():
            btn.click()
            page.wait_for_timeout(300)
    logger.info(f"Expanded {count} truncated reviews")

Exécutez cela après avoir chargé tous les avis, avant l'extraction.

---

Considérations légales et éthiques

Le scraping de données visibles publiquement est généralement légal dans la plupart des juridictions. Le jugement HiQ v. LinkedIn de 2022 aux États-Unis a confirmé que le scraping de données publiques ne viole pas la loi sur la fraude et les abus informatiques.

Cela dit, quelques règles s'appliquent :

• Ne surchargez pas les serveurs. Gardez les requêtes en dessous de 10 par minute pour un usage occasionnel.
• Respectez robots.txt. Le robots.txt de Google restreint certains chemins — vérifiez-le.
• Ne republiez pas le contenu scrappé tel quel. Agrégez et analysez, ne copiez pas-collez.
• Évitez les données personnelles. Les noms des évaluateurs sont publics, mais ne construisez pas de profils sur des individus.
• L'utilisation commerciale nécessite un examen légal. Si vous vendez des données scrappées, consultez un avocat.

L'approche la plus sûre : scraper pour une analyse interne, pas pour la redistribution.

---

Quand le scraping Python n'est pas l'outil adéquat

Écrire et maintenir un scraper Google Maps demande un réel effort. Google change régulièrement sa structure HTML. Les sélecteurs se cassent. Les mesures anti-bot évoluent. Vous passerez du temps à déboguer, pas à analyser.

Si vous avez besoin de données d'avis Google Maps à grande échelle — à travers des centaines ou des milliers d'entreprises — une base de données pré-indexée est plus rapide et plus fiable qu'un scraper fait maison.

IBLead indexe plus de 50 millions d'entreprises dans 37 pays, avec jusqu'à 500 avis Google par fiche : texte complet, évaluation par étoiles, date et nom de l'évaluateur. Les données sont mises à jour chaque semaine et exportées instantanément au format CSV. Pas d'infrastructure de scraping à maintenir, pas de proxies à gérer, pas de sélecteurs à corriger lorsque Google met à jour son frontend.

Pour une recherche ponctuelle sur quelques entreprises, l'approche Python de ce guide fonctionne bien. Pour une génération de leads continue ou un suivi de réputation à grande échelle, 52 $ pour 10 000 leads est difficile à battre.

Commencez gratuitement — 200 crédits inclus

---

FAQ

Combien d'avis puis-je scraper par jour sans être bloqué ?

Commencez de manière conservatrice : 100–500 avis par jour, à travers 5–10 entreprises, avec des délais de 2–3 secondes entre les actions. Avec la rotation des proxies et une bonne gestion des sessions, vous pouvez pousser jusqu'à 1 000–2 000 avis par jour. Le scraping agressif (5 000+ avis/jour) nécessite des réseaux de proxies résidentiels et plusieurs sessions de navigateur fonctionnant en parallèle.

Est-ce que Playwright ou Selenium est meilleur pour scraper les avis Google Maps avec Python ?

Playwright est le meilleur choix pour de nouveaux projets en 2025. Il est 2–3 fois plus rapide, dispose d'un support asynchrone intégré et gère la détection anti-bot avec moins de configuration manuelle. Selenium est toujours valide si vous avez une infrastructure existante ou si vous avez besoin d'un support communautaire maximal. Les deux méthodes fonctionnent — le code de ce guide démontre les deux.

Pourquoi mes sélecteurs retournent-ils des résultats vides ?

Google met régulièrement à jour son frontend. Un sélecteur qui fonctionnait le mois dernier peut ne rien retourner aujourd'hui. La solution : utilisez plusieurs sélecteurs de secours pour chaque champ, et testez avec headless=False afin de voir à quoi ressemble réellement la page. Le modèle extract_with_fallbacks() montré dans ce guide gère cela de manière systématique.

Puis-je scraper des avis Google pour une analyse concurrentielle ?

Oui. Les données d'avis publiques sont accessibles publiquement. Analyser le sentiment des concurrents, suivre les tendances des évaluations ou identifier les plaintes courantes est un cas d'utilisation légitime. Ne republiez pas les avis individuels tels quels ou ne construisez pas de profils personnels sur les évaluateurs. Concentrez-vous sur les insights agrégés.

Comment gérer les CAPTCHA ?

La prévention est préférable à la résolution. Ralentissez votre taux de requêtes, utilisez des proxies résidentiels, ajoutez des délais réalistes et réchauffez les sessions avant de scraper. Lorsqu'un CAPTCHA apparaît quand même : en développement, exécutez avec headless=False et résolvez-le manuellement. En production, intégrez un service de résolution de CAPTCHA ou mettez en œuvre un backoff exponentiel qui attend 5–10 minutes avant de réessayer.