Comment récupérer des avis sur Google Maps : Un guide pratique en Python

Si vous avez déjà essayé de récupérer des avis sur Google Maps en volume significatif, vous connaissez déjà les difficultés : l’API Places officielle ne renvoie qu’une poignée d’avis par lieu, JavaScript gère la majeure partie de l’affichage, et les classes CSS changent suffisamment souvent pour rendre un scraper inopérant entre vendredi et lundi. La bonne nouvelle, c’est que les données sont accessibles ; il suffit de choisir le bon outil pour la tâche.

Ce guide s'adresse aux développeurs Python, aux analystes de données et aux équipes de croissance qui souhaitent extraire les avis d'entreprise de Google Maps à des fins d'analyse de sentiment, d'étude de la concurrence, d'intelligence géographique ou de génération de prospects. Nous aborderons trois méthodes en parallèle : Selenium associé à un proxy pour un contrôle total, une API de scraping avec instructions de rendu pour une approche nécessitant moins de code, et une API JSON par avis lorsque vous avez besoin de champs propres et structurés tels que review_id, iso_date_of_last_editet les réponses des propriétaires.

Vous repartirez avec du code fonctionnel, un tableau comparatif pour justifier l'approche que vous choisirez et un petit pipeline pour nettoyer et analyser les données que vous collecterez. Lorsque les sélecteurs ou les quotas sous-jacents sont connus pour varier, l'article le signale afin que vous puissiez vous y préparer au lieu de devoir le déboguer à 2 heures du matin.

Les avis constituent l’un des ensembles de données les plus pertinents du Web public. Un flux d’avis Maps propre vous permet d’évaluer l’expérience client d’un concurrent, de surveiller la réputation sur l’ensemble des sites, de créer des listes de prospects géolocalisées, d’établir un indice de sentiment régional ou d’entraîner un modèle de recommandation à partir de commentaires humains réels. Rien de tout cela ne fonctionne si vous ne disposez que de moyennes par étoiles, ce qui est exactement le niveau où s’arrêtent la plupart des scrapers de fiches génériques.

Concrètement, les champs que vous pouvez extraire de Google Maps se répartissent en deux niveaux. Au niveau de la fiche, vous obtenez le nom du lieu, l'adresse, la note globale, le nombre d'avis, la catégorie, les horaires, le numéro de téléphone et les options de service telles que le service sur place ou la livraison. Au niveau des avis individuels, vous obtenez le texte de l'avis (l'extrait), le nom de l'auteur, le lien vers son profil, la note par étoiles, la date de l'avis ou de la dernière modification, les URL des photos, la réponse du propriétaire le cas échéant, et des balises thématiques telles que « Service » ou « Ambiance ». Connaître cette distinction dès le départ vous permet de décider si un scraping au niveau des fiches suffit, ou si vous devez approfondir les avis individuels. Les cas d'utilisation liés à l'étude de marché et à la surveillance des avis nécessitent presque toujours le deuxième niveau.

Lorsque vous recherchez comment extraire les avis de Google Maps, trois voies s’offrent à vous. Choisir la mauvaise est la raison la plus courante pour laquelle les équipes abandonnent en cours de route, alors prenez quelques minutes pour réfléchir avant d’écrire du code.

L'API officielle Google Places est la plus sûre sur le plan juridique, mais elle est conçue pour l'intégration d'applications, pas pour l'analyse. Selon la documentation de Google, les requêtes de détails sur les lieux ne renvoient qu'un petit sous-ensemble limité des avis affichés dans l'interface utilisateur de Maps, ce qui la rend peu adaptée à l'évaluation du sentiment à quelque échelle que ce soit. Un scraper Selenium fait maison associé à un proxy résidentiel vous offre un contrôle total et la même vue qu'un utilisateur non connecté, au prix de l'exécution d'un navigateur et de la gestion des modifications CSS. Une API de scraping intermédiaire prend en charge la rotation des proxys, la gestion des CAPTCHA et le rendu headless, tandis qu'une API JSON par avis, en plus de cela, se charge également de l'analyse.

Utilisez le tableau ci-dessous comme matrice de décision justifiable.

Maps est plus difficile à scraper qu'un site de commerce électronique classique, et ce n'est pas pour les raisons auxquelles on s'attendrait. La première difficulté que vous rencontrez est le mur de consentement aux cookies, qui empêche l'affichage du panneau de résultats de recherche tant qu'il n'est pas ignoré. La deuxième est que Maps est une expérience exclusivement JavaScript, donc une simple requête requests.get renvoie une coquille presque vide. Le troisième obstacle, et celui qui bloque le plus souvent les scrapers, est que le panneau de résultats utilise un chargement par défilement au lieu d’URL paginées. Il n’y a pas ?page=2 que vous puissiez atteindre.

De plus, Google obscurcit et fait tourner les noms de classes CSS. Des hooks comme hfpxzc, MW4etd, UY7F9et Nv2PK étaient valides au moment de la rédaction, mais ils doivent être revérifiés avant publication ou exécution car ils changent souvent. Les modèles de requêtes agressifs provenant d’une seule adresse IP entraînent également des limites de débit et, parfois, un reCAPTCHA, c’est pourquoi un pool de proxys résidentiels et des délais d’attente aléatoires ne sont pas facultatifs dès que l’on dépasse une poignée de requêtes.

Vous aurez besoin de Python 3.10 ou d'une version plus récente et d'une installation récente de Chrome. Le parcours Selenium nécessite également quelques paquets. Installez-les avec pip :

pip install selenium selenium-wire webdriver-manager beautifulsoup4 lxml requests

Chacun a son utilité. Selenium pilote le navigateur. Selenium Wire est une extension légère qui expose les requêtes HTTP sous-jacentes afin que vous puissiez associer un proxy authentifié sans avoir à jongler avec les drapeaux Chrome. Webdriver Manager gère le binaire ChromeDriver afin que vous n'ayez pas à fixer une version spécifique sur chaque ordinateur portable. BeautifulSoup avec le backend lxml analyse le HTML rendu, et requests suffit pour les modules API.

Pour les méthodes 2 et 3, créez un compte SERP API avant de commencer. Vous pouvez généralement obtenir un crédit gratuit pour effectuer des tests, puis insérer la clé dans les blocs de code ci-dessous.

La réponse classique à la question de savoir comment extraire les avis de Google Maps consiste à utiliser un navigateur réel associé à un proxy résidentiel rotatif. C'est l'approche qui offre la plus grande couverture et le plus de contrôle. Vous lancez une instance de Chrome, acheminez son trafic via le proxy, faites défiler la page jusqu’à ce qu’un nombre suffisant de fiches s’affiche, puis analysez le code source de la page avec BeautifulSoup. C’est le choix idéal lorsque vous avez besoin de flexibilité (flux de clics personnalisés, capture d’écran, profils d’entreprise protégés par connexion) ou que votre échelle est suffisamment petite pour gérer manuellement les sélecteurs. Les cinq sous-sections ci-dessous vous guident pas à pas, avec du code que vous pouvez coller directement dans un script.

L'astuce pour extraire les avis Google Maps avec Selenium consiste à envoyer chaque requête via un proxy résidentiel rotatif. Selenium seul ne peut pas transmettre correctement les identifiants d'authentification HTTP de base, c'est là que Selenium Wire entre en jeu. Il expose le bloc proxy dans seleniumwire_options et gère la négociation d'authentification en arrière-plan. Le modèle d'URL de proxy attendu par la plupart des fournisseurs ressemble à http://<username>:<password>@<host>:<port>, avec des paramètres supplémentaires tels que render ou country_code ajoutés au nom d'utilisateur. Vérifiez le format exact dans la documentation actuelle de votre fournisseur avant de l'utiliser en production, car les conventions d'URL varient.

from seleniumwire import webdriver
from selenium.webdriver.chrome.service import Service
from webdriver_manager.chrome import ChromeDriverManager

API_KEY = "YOUR_API_KEY"
PROXY = (
    f"http://scrape.render=true.country_code=us:{API_KEY}"
    "@proxy-server.example.com:8001"
)

options = webdriver.ChromeOptions()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")

sw_options = {"proxy": {"http": PROXY, "https": PROXY, "no_proxy": "localhost,127.0.0.1"}}

driver = webdriver.Chrome(
    service=Service(ChromeDriverManager().install()),
    seleniumwire_options=sw_options,
    options=options,
)
driver.implicitly_wait(30)

Le mode headless réduit l'utilisation de la mémoire sur les serveurs, et l'attente implicite de 30 secondes laisse le temps à Maps de s'afficher avant que les recherches de sélecteurs ne se déclenchent. Si vous souhaitez une introduction plus approfondie à Selenium, la documentation sur les liaisons de langage passe en revue chaque option en détail.

Une fois le pilote configuré, pointez-le vers une URL de recherche telle que https://www.google.com/maps/search/pizza+in+new+york. Maps affiche généralement une boîte de dialogue de consentement aux cookies lors du premier chargement d'une session, et la mise en page ne vous permettra pas de faire défiler les résultats tant que vous ne l'aurez pas fermée. Enveloppez le clic dans un try/except, car le trafic rendu par proxy dans certaines régions ignore complètement la boîte de dialogue.

from selenium.webdriver.common.by import By

driver.get("https://www.google.com/maps/search/pizza+in+new+york")

try:
    accept_btn = driver.find_element(
        By.XPATH, "//button[.//span[contains(text(), 'Accept all')]]"
    )
    accept_btn.click()
except Exception:
    print("Cookie consent not shown for this session.")

Enregistrez toujours l'échec au lieu de laisser l'exception remonter. Vous souhaitez que l'exécution se poursuive lorsque la boîte de dialogue est absente, et non qu'elle s'interrompe. Si votre locale affiche un libellé de bouton différent, remplacez le texte XPath ou utilisez une aria-label correspondance sur la bannière de consentement.

Maps ne pagine pas. Lorsque vous faites défiler le panneau de gauche, il charge en continu davantage de listes dans le DOM et finit par atteindre un marqueur de fin. Pour extraire des avis de Google Maps à une échelle raisonnable, vous devez piloter ce défilement vous-même. Deux méthodes fonctionnent bien. La première utilise des frappes au clavier via ActionChains, ce qui donne l'impression d'un utilisateur réel. Le second utilise un exécuteur JavaScript, qui est plus rapide mais plus facile à identifier.

import time
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys

def scroll_panel_down(driver, panel_xpath, presses=5, pause_time=1):
    panel = driver.find_element(By.XPATH, panel_xpath)
    actions = ActionChains(driver)
    actions.move_to_element(panel).click().perform()
    for _ in range(presses):
        actions.send_keys(Keys.PAGE_DOWN).perform()
        time.sleep(pause_time)

# Cleaner JS-executor alternative
def scroll_panel_js(driver, panel_xpath, rounds=8, pause=1.2):
    panel = driver.find_element(By.XPATH, panel_xpath)
    for _ in range(rounds):
        driver.execute_script("arguments[0].scrollTop = arguments[0].scrollHeight", panel)
        time.sleep(pause)

Réglez presses et pause_time en fonction de votre requête cible. Cinq défilements vers le bas avec une pause d’une seconde constituent un point de départ raisonnable, mais une requête portant sur une ville dense peut nécessiter 15 cycles ou plus avant que le panneau ne signale 'You've reached the end of the list'. Surveillez le code HTML généré et arrêtez-vous lorsque de nouvelles fiches cessent d'apparaître.

Une fois que le panneau a chargé suffisamment d’annonces, transmettez le code source de la page à BeautifulSoup et extrayez les champs. Les hooks de classe ci-dessous étaient valides au moment de la rédaction, mais Maps les modifie selon son propre calendrier ; effectuez donc toujours une nouvelle vérification du DOM avant une exécution en production.

from bs4 import BeautifulSoup

soup = BeautifulSoup(driver.page_source, "lxml")

# These class names rotate. Re-verify before each run.
titles = soup.find_all("a", class_="hfpxzc")        # listing anchors
ratings = soup.find_all("span", class_="MW4etd")      # numeric rating
counts = soup.find_all("span", class_="UY7F9")        # review count

places = []
for i, t in enumerate(titles):
    place = {
        "name": t.get("aria-label") or t.get_text(strip=True),
        "url": t.get("href"),
        "rating": ratings[i].get_text(strip=True) if i < len(ratings) else "N/A",
        "review_count": counts[i].get_text(strip=True) if i < len(counts) else "N/A",
    }
    places.append(place)

Deux habitudes de résilience sont importantes ici. Premièrement, privilégiez l' aria-label attribut au texte visible, car le libellé est plus stable face aux modifications de l'interface utilisateur. Deuxièmement, utilisez des recherches index-safe afin qu'une note manquante ne bloque pas la boucle. Si vous souhaitez une introduction plus approfondie à BeautifulSoup, un guide interne sur les modèles d'analyse est un complément utile pour découvrir des stratégies de sélection plus avancées.

La dernière étape de la méthode 1 consiste à écrire vos listes analysées sur le disque. Le format CSV convient pour les tâches ponctuelles, et le passage à Parquet ou à une base de données ne nécessite qu'une modification d'une ligne par la suite.

import csv

with open("maps_pizza_places.csv", "w", encoding="utf-8", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["name", "rating", "review_count", "url"])
    for p in places:
        writer.writerow([
            p.get("name") or "N/A",
            f"{p['rating']}/5" if p["rating"] != "N/A" else "N/A",
            p.get("review_count") or "N/A",
            p.get("url") or "N/A",
        ])

driver.quit()

Remplacez toujours par défaut les champs manquants par une sentinelle telle que N/A plutôt qu’une cellule vide. Les cellules vides sont ambiguës dans les pipelines en aval (le champ était-il manquant ou le scraping a-t-il échoué ?) et elles compliquent les contrôles de qualité des données. Appeler driver.quit() à la fin libère le processus Chrome et toutes les connexions proxy qu'il détenait.

La méthode 1 convient pour les prototypes, mais elle est lourde. La solution de production plus propre pour extraire les avis de Google Maps à grande échelle consiste à déléguer le rendu et la rotation des proxys à une API de scraping et à envoyer un ensemble d'instructions JSON qui indique à un navigateur headless hébergé ce qu'il doit faire sur la page. Vous obtenez le même code HTML final, sans la surcharge du navigateur local, et le fournisseur prend en charge les tentatives de reconnexion et la rotation des proxys dont vous devriez autrement vous occuper vous-même.

La plupart des fournisseurs, y compris notre API SERP WebScrapingAPI, acceptent un ensemble d'instructions JSON dans les en-têtes de requête décrivant les défilements, les clics et les temps d'attente. L'exemple ci-dessous ferme la bannière de cookies, fait défiler le panneau de résultats plusieurs fois et renvoie le code HTML final en une seule requête. Vérifiez les noms exacts des en-têtes et le schéma des instructions dans la documentation actuelle du fournisseur, car ces détails varient.

import json, requests
from bs4 import BeautifulSoup

API_KEY = "YOUR_API_KEY"
TARGET_URL = "https://www.google.com/maps/search/pizza+in+new+york"

instructions = [
    {"type": "click", "selector": "button[aria-label='Accept all']", "optional": True},
    {"type": "scroll", "selector": "div[role='feed']", "repeat": 8, "delay": 1500},
    {"type": "wait", "value": 2000},
]

headers = {
    "x-api-key": API_KEY,
    "x-render-js": "true",
    "x-instruction-set": json.dumps(instructions),
}

resp = requests.get("https://api.example-scraper.com/v1",
                    params={"url": TARGET_URL}, headers=headers, timeout=120)

soup = BeautifulSoup(resp.text, "lxml")
listings = soup.find_all("div", class_="Nv2PK")  # re-verify class before each run
print(f"Got {len(listings)} listings.")

Trois éléments justifient le passage à ce modèle. Premièrement, vous n'avez plus besoin d'exécuter et de mettre à jour Chrome sur chaque worker. Deuxièmement, le fournisseur gère la rotation des proxys et les tentatives de requêtes ayant échoué à votre place, ce qui élimine la plupart des difficultés opérationnelles liées aux jours difficiles. Troisièmement, l'ensemble du pipeline peut s'exécuter dans une tâche cron ou une fonction sans serveur, sans dépendance vis-à-vis d'un navigateur.

Le scraping au niveau des fiches vous indique quels lieux sont importants, mais la valeur commerciale se trouve un niveau plus bas, dans le texte réel des avis. La réponse la plus simple à la question de savoir comment extraire les avis de Google Maps au niveau de chaque avis est de sauter complètement l'analyse et d'utiliser une API structurée de Google Maps Reviews. Vous recherchez une fois la fiche d'un lieu data_id une seule fois, puis d'appeler le point de terminaison des avis avec les paramètres dont vous avez besoin.

La structure est intuitive. engine sélectionne le moteur Maps Reviews. data_id identifie le lieu. sort_by contrôle le classement : qualityScore (par défaut, les plus pertinents), newestFirst, ratingHigh, ou ratingLow. topic_id filtre selon un thème spécifique, par exemple un identifiant de rubrique « Équipements » extrait de la réponse structurée (le brief indiquait un identifiant d'exemple /m/0f3yyn à des fins de vérification). Les champs facultatifs tels que Snippet, Responseet Response.iso_date sont indexés à partir de zéro, la première évaluation se trouvant à l'index 0.

import requests

params = {
    "engine": "google_maps_reviews",
    "data_id": "0x80dcd1f0c5cb6f53:0xd2c4f5c30e2b7c5a",
    "sort_by": "newestFirst",
    "api_key": "YOUR_API_KEY",
}

r = requests.get("https://api.example-reviews.com/search", params=params, timeout=60).json()

for rev in r.get("reviews", []):
    print({
        "user": rev.get("user", {}).get("name"),
        "rating": rev.get("rating"),
        "date": rev.get("iso_date_of_last_edit"),
        "text": rev.get("snippet", "No review text, rating only"),
        "owner_response": rev.get("response", {}).get("snippet", "No response from owner"),
    })

Considérez toujours les champs manquants comme par défaut. Les évaluateurs laissent souvent une note par étoiles sans texte, et la plupart des propriétaires ne répondent jamais, ce qui fait que le JSON comportera des lacunes.

Les voies API et DIY limitent toutes deux le premier lot à un petit nombre. Selon la documentation des fournisseurs, une API Maps Reviews typique renvoie environ 10 avis par requête et expose un next_page_token (ou un curseur équivalent) dans la réponse. La boucle de pagination est la même que celle que vous utiliseriez pour n'importe quelle API basée sur des jetons : continuez à appeler jusqu'à ce que le champ du jeton soit vide.

all_reviews, token = [], None
while True:
    p = dict(params, **({"next_page_token": token} if token else {}))
    r = requests.get(URL, params=p, timeout=60).json()
    all_reviews.extend(r.get("reviews", []))
    token = r.get("serpapi_pagination", {}).get("next_page_token")
    if not token:
        break

Du côté de Selenium, la pagination consiste simplement à continuer à faire défiler l'onglet « Avis » de la fiche de lieu. Surveillez le message « Vous avez atteint la fin de la liste » et arrêtez-vous lorsque le nombre d'avis affichés cesse d'augmenter après deux défilements consécutifs.

Une fois que vous comprenez comment extraire mécaniquement les avis de Google Maps, le plus long est de rester débloqué. Le volume et la discrétion sont un compromis, pas un paramètre fixe. Le levier le plus important est votre pool de proxys. Les adresses IP de centres de données sont signalées lors des requêtes Maps bien plus rapidement que les adresses résidentielles ; donc, dès que vous dépassez quelques dizaines de requêtes par heure, prévoyez de faire tourner des adresses IP résidentielles avec un ciblage au niveau du pays. Intégrez des délais d'attente aléatoires entre les actions (une fourchette de 300 à 1 500 ms est raisonnable), réduisez de manière exponentielle les tentatives en cas de code 429, et limitez toujours le nombre de tentatives afin qu'une cible défaillante n'épuise pas tout votre budget.

La dérive du sélecteur est le deuxième mode de défaillance. Traitez les hooks comme hfpxzc, MW4etdet Nv2PK comme volatils. Mettez en place une étape de surveillance du DOM légère qui signale clairement une erreur lorsqu’un sélecteur ne correspond plus à quoi que ce soit, privilégiez aria-label et les sélecteurs structurels aux noms de classe lorsque c’est possible, et gardez au moins une solution de secours par champ critique. Une petite fiche pratique sur les signaux de blocage courants et comment les contourner mérite d’être mise en favori, et le guide plus complet de notre équipe sur la prévention des interdictions d’IP approfondit la rotation des en-têtes et l’empreinte digitale (une lecture complémentaire utile lorsqu’un script autrefois stable commence soudainement à renvoyer des 403).

Le but de tout cela est d'obtenir des données prêtes à l'emploi, pas un énorme fichier CSV. Un petit pipeline de post-traitement transforme les avis bruts en informations exploitables par une équipe produit ou marketing.

import pandas as pd
from textblob import TextBlob

df = pd.DataFrame(all_reviews)
df = df.drop_duplicates(subset=["review_id"])  # dedupe
df["rating"] = df["rating"].astype(float).clip(0, 5)  # normalize
df["text"] = df["snippet"].fillna("").str.replace(r"[\u200b-\u200f]", "", regex=True)
df["sentiment"] = df["text"].apply(lambda t: TextBlob(t).sentiment.polarity if t else 0.0)

Quatre étapes suffisent pour effectuer l'essentiel du travail : dédupliquer en review_id, le recadrage des notes sur une échelle de 0 à 5, la suppression des espaces vides et des emojis parasites du texte, et le marquage de la polarité du sentiment par ligne à l'aide d'une bibliothèque NLP légère. À partir de là, il s'agit simplement d'une étape de conversion de Pandas vers SQL ou vers un entrepôt de données. Ce résultat alimente un tableau de bord de suivi des avis ou un benchmark du sentiment des concurrents, ce qui boucle la boucle vers les cas d'utilisation avec lesquels nous avons commencé.

• L'API Google Places officielle est pratique pour intégrer quelques avis dans un produit, mais ses limites par lieu en font un outil inadapté à l'analyse ou à l'étude de la concurrence.
• Une pile Selenium associée à des proxys résidentiels vous offre le plus de contrôle. Prévoyez des bannières de cookies, un chargement par défilement et des hooks de classes CSS rotatives comme hfpxzc et Nv2PK.
• Une API de scraping avec un jeu d'instructions de rendu JSON élimine complètement le navigateur local et constitue la solution la plus propre pour les tâches planifiées et répétitives.
• Une API Maps Reviews structurée est le moyen le plus rapide d'obtenir des champs propres pour chaque avis. Utilisez sort_by, topic_idet next_page_token pour contrôler la profondeur et le découpage.
• Considérez le pipeline comme un pipeline. Dédupliquez en review_id, normalisez les notes, éliminez le bruit et marquez le sentiment afin que le résultat soit prêt à être utilisé pour la prise de décision, et non simplement stocké.

Les données d'avis publics sont généralement considérées comme pouvant être extraites dans de nombreuses juridictions lorsqu'elles sont utilisées à des fins d'analyse ou de recherche, mais les Conditions d'utilisation de Google restreignent l'accès automatisé à ses produits, et la jurisprudence américaine relative à l'extraction de données publiques continue d'évoluer. Vérifiez toujours les conditions d'utilisation de Maps, respectez robots.txt, évitez de collecter des données personnelles au-delà de ce qui est visible publiquement et consultez un avocat avant toute utilisation commerciale.

L'API Places est soumise à des limites de débit, nécessite un projet Google Cloud payant et ne renvoie qu'un petit sous-ensemble des avis affichés dans l'interface utilisateur de Maps. Cela convient pour intégrer quelques avis dans un produit, mais est inutilisable pour l'analyse des sentiments, l'analyse comparative des concurrents ou tout autre cas d'utilisation nécessitant un échantillon représentatif.

Pas de manière fiable avec les données brutes requests, car Maps est une application SPA (Single Page Application) très gourmande en JavaScript. Les alternatives réalistes sont une API de scraping qui exécute pour vous un navigateur headless hébergé, ou une API Reviews structurée qui renvoie du JSON parsé sans rien afficher côté client.

Assez souvent pour que vous ne deviez pas considérer qu'un hook de classe est permanent. Protégez-vous contre les dérives avec aria-label des sélecteurs, des solutions de repli XPath structurelles, une petite tâche de surveillance du DOM qui signale clairement une erreur lorsqu’un sélecteur ne renvoie aucune correspondance, et une alerte qui vous prévient avant la prochaine exécution programmée.

Une API Maps Reviews typique renvoie environ 10 avis par requête et un next_page_token curseur pour le lot suivant. Il n’y a pas de limite totale fixe, mais les avis très anciens sont plus difficiles à récupérer. Parcourez les jetons jusqu’à ce qu’aucun ne soit renvoyé, et du côté de Selenium, continuez à faire défiler l’onglet des avis jusqu’à ce que le nombre cesse d’augmenter.

Il n'y a pas de réponse unique à la question de savoir comment extraire les avis de Google Maps. La bonne réponse dépend de la quantité de données dont vous avez besoin, de la fréquence à laquelle vous en avez besoin et de la charge opérationnelle que vous pouvez supporter. Pour un audit ponctuel des emplacements d'un concurrent, Selenium associé à un proxy résidentiel suffit amplement. Pour un pipeline de sentiment récurrent qui doit continuer à fonctionner alors que Google modifie les noms de classes et renforce sa protection anti-bot, une API de scraping gérée ou une API structurée de Maps Reviews est la solution qui vous permettra de dormir sur vos deux oreilles.

Quelle que soit la méthode choisie, traitez le résultat comme des données et non comme du code HTML. Dédupliquez par ID d'avis, normalisez les notes, éliminez le bruit, évaluez le sentiment et chargez le tout dans un système consultable afin que le travail porte ses fruits dans un tableau de bord ou un modèle plutôt que dans un fichier CSV obsolète.

Si vous préférez ne pas gérer et maintenir une flotte de Chrome uniquement pour suivre les changements de l'interface utilisateur de Maps, notre API Scraper SERP chez WebScrapingAPI gère la rotation des proxys, le rendu headless et la résolution des CAPTCHA derrière un seul point de terminaison. Vous pouvez ainsi conserver le code Python de ce guide et simplement remplacer la couche de récupération. Générez une clé API, pointez-la vers une URL Maps, et commencez à collecter des données d'avis propres en l'espace d'un après-midi.