Google Maps est l'une des sources les plus riches d'informations sur les entreprises locales sur le web ouvert. Recherchez une catégorie dans une ville et vous obtenez une liste classée d'établissements, chacun avec un nom, une adresse, un numéro de téléphone, une catégorie, une note en étoiles et un nombre d'avis. Pour la génération de prospects locaux, la recherche de marché et l'analyse concurrentielle, ces données publiques de listing sont précieuses : elles vous indiquent qui opère dans une zone, comment ils sont notés et comment les contacter.
Ce guide vous montre comment scraper des données depuis Google Maps avec Python de manière fiable. Vous construisez un petit scraper fonctionnel qui récupère une page de résultats Google Maps rendue via la Crawling API, analyse chaque carte de lieu avec BeautifulSoup, collecte les champs principaux de l'entreprise, gère plusieurs résultats et exporte les données en JSON et CSV. L'ensemble de la démonstration se limite aux listings d'entreprises publics que tout le monde peut voir sur la carte sans compte, et la section légalité vers la fin n'est pas du remplissage, lisez-la avant de pointer cet outil sur un volume réel.
Ce que vous allez construire
Un script Python qui prend une URL de recherche Google Maps publique, récupère le HTML rendu via la Crawling API et extrait un enregistrement structuré pour chaque lieu dans le panneau de résultats. Nous utiliserons "restaurants in New York" comme exemple tout au long de ce tutoriel, la même cible que la version originale de ce tutoriel utilisait, et nous extrairons ces champs de chaque listing :
- Nom le nom de l'entreprise tel qu'affiché sur la carte du lieu.
- Adresse l'adresse postale ou le label de zone pour le lieu.
- Téléphone le numéro de contact, quand le listing en expose un.
- Catégorie le label de type d'entreprise, par exemple "Italian restaurant".
- Note la note moyenne en étoiles sous forme de nombre.
- Nombre d'avis le nombre d'avis sur lequel cette note est basée.
À la fin, vous aurez ces enregistrements pour chaque lieu de la page, écrits à la fois dans maps_results.json et maps_results.csv, prêts pour un CRM, un tableur ou une base de données.
Pourquoi une requête simple échoue sur Google Maps
Si vous envoyez une requête HTTP basique vers une URL Google Maps depuis un script, vous n'obtenez pas la liste ordonnée de lieux que vous voyez dans votre navigateur. Le panneau de résultats est construit par JavaScript après le chargement initial de la page : le HTML brut retourné par un simple requests.get est principalement un squelette vide, avec les vraies cartes de lieux remplies par des scripts qui s'exécutent dans un vrai navigateur. Analysez ce squelette et vous ne trouverez aucun des champs que vous cherchez.
De plus, Google surveille attentivement le trafic automatisé. Les requêtes qui ne ressemblent pas à celles d'un vrai navigateur, ou qui arrivent en rafales depuis une IP de datacenter, sont confrontées à un CAPTCHA, à un mur de consentement, ou bloquées avant même d'atteindre les listings. La version originale de ce tutoriel s'appuyait sur un endpoint JSON interne pour éviter le rendu, mais ces URLs privées changent sans préavis et se cassent dès que Google les restructure. L'approche durable consiste à rendre la page publique comme le ferait un navigateur.
Un scraper Google Maps fonctionnel a donc besoin de deux choses en une seule requête : une IP que la plateforme considère comme un visiteur réel, et un navigateur qui exécute le JavaScript de la page pour que les cartes de lieux apparaissent réellement. Vous pouvez assembler cela vous-même avec un navigateur sans tête et un pool de proxies résidentiels rotatifs, mais maintenir cette infrastructure en bon état représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL, elle la récupère depuis une IP résidentielle de confiance, rend la page et renvoie le HTML terminé à analyser.
Prérequis
Quelques éléments doivent être en place avant d'écrire du code. Aucun ne prend beaucoup de temps.
Bases de Python. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si BeautifulSoup est nouveau pour vous, notre guide d'utilisation de BeautifulSoup en Python couvre les bases de l'analyse que ce tutoriel suppose.
Python 3.8 ou version ultérieure. Vérifiez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.
Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token de requête depuis la page de documentation du compte. Vous obtenez jusqu'à 20 000 requêtes gratuites, sans carte bancaire. Google Maps nécessite le rendu JavaScript, utilisez donc votre token JavaScript pour ces requêtes. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du contrôle de version.
Configurer le projet
Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les deux bibliothèques dont le scraper a besoin.
python --version python -m venv maps_env source maps_env/bin/activate pip install requests beautifulsoup4
Sous Windows, activez l'environnement avec maps_env\Scripts\activate à la place de la ligne source. Deux dépendances font le travail : requests envoie l'appel HTTP vers la Crawling API, et beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire des champs individuels par sélecteur CSS.
Étape 1 : Obtenir l'URL de recherche
Ouvrez Google Maps dans votre navigateur et recherchez "restaurants in New York". Les lieux apparaissent dans le panneau défilant à gauche, et l'URL dans votre barre d'adresse se met à jour pour encoder la requête. Copiez cette URL. C'est la même adresse que vous transmettrez au scraper, donc ce que vous voyez dans le navigateur est ce que l'API rend.
https://www.google.com/maps/search/restaurants+in+New+York
Le chemin /maps/search/ est le point d'entrée stable et public pour une recherche par catégorie, avec la requête jointe par des signes +. Vous pouvez substituer n'importe quelle catégorie et localisation, par exemple plumbers+in+Chicago ou coffee+shops+in+Austin, et le reste du scraper reste identique. Évitez les longues URLs internes avec des paramètres pb= que le navigateur génère parfois ; celles-ci sont privées et se cassent sans avertissement.
Étape 2 : Récupérer la page rendue via la Crawling API
Commencez par obtenir le HTML. Écrivez une petite fonction crawl() qui envoie votre URL cible à la Crawling API avec votre token JavaScript, lui demande de rendre la page, vérifie que la page sous-jacente est revenue avec un statut 200 et retourne le corps HTML. Vérifier le statut avant d'analyser permet de rendre les échecs visibles plutôt que silencieux.
import json import requests API_TOKEN = "YOUR_CRAWLBASE_TOKEN" # use your JavaScript token API_ENDPOINT = "https://api.crawlbase.com/" def crawl(url): params = { "token": API_TOKEN, "url": url, "page_wait": 4000, } response = requests.get(API_ENDPOINT, params=params) response.raise_for_status() data = json.loads(response.text) if data["original_status"] != 200: raise Exception(f"Unable to crawl '{url}'") return data["body"] if __name__ == "__main__": url = "https://www.google.com/maps/search/restaurants+in+New+York" html = crawl(url) print(html[:500])
L'API retourne une enveloppe JSON, donc vous chargez la réponse avec json.loads et lisez deux champs : original_status est le statut que Google lui-même a retourné, et body est le HTML rendu de la page. Le paramètre page_wait indique au renderer d'attendre quelques secondes après le chargement pour que les cartes de lieux aient le temps de se remplir avant que le HTML soit capturé. Vérifier original_status signifie qu'un mur de consentement ou un blocage remonte comme exception plutôt que d'alimenter un squelette vide dans l'analyseur. Exécutez le script avec python crawling.py et vous devriez voir le vrai balisage de carte dans les 500 premiers caractères, ce qui confirme que la récupération et le rendu fonctionnent avant d'écrire un seul sélecteur.
Cette vérification original_status ne lit 200 que parce que la requête a atteint Google Maps comme un visiteur réel et que la page a d'abord été rendue dans un vrai navigateur. La Crawling API récupère depuis une IP résidentielle rotative, exécute le JavaScript de la page pour que les cartes de lieux apparaissent réellement, et vous remet le HTML terminé, vous évitant d'exploiter une flotte de navigateurs sans tête et de sourcer un pool de proxies résidentiels vous-même. Pointez-la sur une URL de recherche Maps publique avec le niveau gratuit d'abord.
Étape 3 : Analyser chaque carte de lieu avec BeautifulSoup
Avec le HTML rendu en main, chargez-le dans BeautifulSoup et extrayez chaque résultat par son sélecteur. Google Maps enveloppe chaque lieu du panneau de résultats dans un élément article, et chaque champ se trouve à un endroit prévisible à l'intérieur de cette carte. Inspectez la page en direct dans les outils de développement de votre navigateur (clic droit sur une carte de lieu, puis Inspecter) pour confirmer les noms de classe et d'attribut actuels ; les sélecteurs ci-dessous correspondent à la mise en page au moment de la rédaction.
import re from bs4 import BeautifulSoup def parse_place(card): name_el = card.select_one("div.qBF1Pd") rating_el = card.select_one("span.MW4etd") reviews_el = card.select_one("span.UY7F9") info_rows = card.select("div.W4Efsd > div.W4Efsd") category, address, phone = None, None, None for row in info_rows: text = row.get_text(" ", strip=True) phone_match = re.search(r"(\(?\d[\d\-\s\(\)]{7,}\d)", text) if phone_match and not phone: phone = phone_match.group(1).strip() elif "·" in text and not category: parts = [p.strip() for p in text.split("·")] category = parts[0] address = parts[-1] if len(parts) > 1 else None return { "name": name_el.get_text(strip=True) if name_el else None, "category": category, "address": address, "phone": phone, "rating": float(rating_el.get_text(strip=True)) if rating_el else None, "reviews": parse_reviews(reviews_el), } def parse_reviews(el): if not el: return 0 digits = re.sub(r"[^\d]", "", el.get_text(strip=True)) return int(digits) if digits else 0 def scrape_html(html): soup = BeautifulSoup(html, "html.parser") cards = soup.select("div[role='article']") return [parse_place(card) for card in cards if card.select_one("div.qBF1Pd")]
Le sélecteur div[role='article'] correspond à chaque carte de lieu dans le panneau de résultats, et le helper lit les champs nommés à l'intérieur. Le nom de l'entreprise se trouve dans div.qBF1Pd, la note en étoiles dans span.MW4etd, et le nombre d'avis dans span.UY7F9 sous forme de texte comme "(1,234)", que parse_reviews réduit à un entier. La catégorie, l'adresse et le téléphone partagent les lignes d'info secondaires sous div.W4Efsd, séparées par un point médian, donc nous découpons sur "·" pour extraire la catégorie et l'adresse et utilisons une petite expression régulière pour repérer un numéro de téléphone. Lire chaque champ de manière défensive, avec un repli sur None, signifie qu'un listing qui omet un téléphone ou une note produit quand même un enregistrement propre au lieu de faire planter la boucle.
Les noms de classe de Google, comme qBF1Pd et MW4etd, sont des artefacts de compilation obfusqués qui changent quand Google redéploie son interface. Traitez les sélecteurs ci-dessus comme un modèle de départ, pas un contrat. Quand un champ revient vide pour chaque résultat, ré-inspectez une carte de lieu en direct dans les outils de développement de votre navigateur et mettez à jour le sélecteur. La maintenance périodique des sélecteurs est normale pour tout scraper en production, ce n'est pas le signe que quelque chose est cassé.
Étape 4 : Gérer plusieurs résultats et assembler le script
Le panneau de résultats contient de nombreux lieux, et l'analyseur retourne déjà un enregistrement par carte, donc la gestion de plusieurs résultats est intégrée. Maintenant, reliez la récupération et l'analyse en un script fonctionnel et exportez les enregistrements en JSON et CSV. Le CSV est le format que la plupart des flux de génération de prospects et de recherche préfèrent, car il s'intègre directement dans un tableur ou une importation CRM.
import csv import json import re import requests from bs4 import BeautifulSoup API_TOKEN = "YOUR_CRAWLBASE_TOKEN" API_ENDPOINT = "https://api.crawlbase.com/" FIELDS = ["name", "category", "address", "phone", "rating", "reviews"] def crawl(url): params = {"token": API_TOKEN, "url": url, "page_wait": 4000} response = requests.get(API_ENDPOINT, params=params) response.raise_for_status() data = json.loads(response.text) if data["original_status"] != 200: raise Exception(f"Unable to crawl '{url}'") return data["body"] def parse_reviews(el): if not el: return 0 digits = re.sub(r"[^\d]", "", el.get_text(strip=True)) return int(digits) if digits else 0 def parse_place(card): name_el = card.select_one("div.qBF1Pd") rating_el = card.select_one("span.MW4etd") reviews_el = card.select_one("span.UY7F9") info_rows = card.select("div.W4Efsd > div.W4Efsd") category, address, phone = None, None, None for row in info_rows: text = row.get_text(" ", strip=True) phone_match = re.search(r"(\(?\d[\d\-\s\(\)]{7,}\d)", text) if phone_match and not phone: phone = phone_match.group(1).strip() elif "·" in text and not category: parts = [p.strip() for p in text.split("·")] category = parts[0] address = parts[-1] if len(parts) > 1 else None return { "name": name_el.get_text(strip=True) if name_el else None, "category": category, "address": address, "phone": phone, "rating": float(rating_el.get_text(strip=True)) if rating_el else None, "reviews": parse_reviews(reviews_el), } def scrape_html(html): soup = BeautifulSoup(html, "html.parser") cards = soup.select("div[role='article']") return [parse_place(c) for c in cards if c.select_one("div.qBF1Pd")] def main(): url = "https://www.google.com/maps/search/restaurants+in+New+York" html = crawl(url) places = scrape_html(html) with open("maps_results.json", "w", encoding="utf-8") as f: json.dump(places, f, ensure_ascii=False, indent=2) with open("maps_results.csv", "w", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=FIELDS) writer.writeheader() writer.writerows(places) print(f"Saved {len(places)} places to JSON and CSV") if __name__ == "__main__": main()
Exécutez le script complet avec python main.py. Il récupère la page de résultats rendue pour "restaurants in New York", extrait un enregistrement pour chaque carte de lieu et écrit tout dans maps_results.json et maps_results.csv. Le DictWriter utilise la même liste FIELDS comme en-tête CSV et ordre de colonnes, de sorte que les deux sorties restent synchronisées. Remplacez la requête dans l'URL et l'analyseur gère ce qui revient.
À quoi ressemble la sortie
Vous obtenez une liste propre d'enregistrements de lieux, chacun avec les six champs, prêts à être écrits en JSON, CSV ou dans une base de données. Voici un échantillon JSON tronqué.
[ { "name": "Carmine's Italian Restaurant", "category": "Italian restaurant", "address": "200 W 44th St", "phone": "(212) 221-3800", "rating": 4.5, "reviews": 12873 }, { "name": "Katz's Delicatessen", "category": "Deli", "address": "205 E Houston St", "phone": "(212) 254-2246", "rating": 4.6, "reviews": 48091 } ]
Le CSV contient les mêmes données avec un lieu par ligne et les colonnes dans l'ordre FIELDS : name,category,address,phone,rating,reviews. Ce format s'importe proprement dans un tableur pour la déduplication, ou dans un CRM comme point de départ d'une liste de prospects locaux.
Passer à l'échelle sur plusieurs villes et requêtes
Une recherche dans une ville est une démonstration ; un vrai travail exécute le même scraper sur de nombreuses paires catégorie et localisation. L'URL est la seule chose qui change, donc construisez une liste de requêtes et bouclez dessus, en analysant chacune avec la même fonction. La seule habitude qui maintient une longue exécution en bonne santé est le rythme, donc faites une pause entre les requêtes plutôt que de les envoyer dans une boucle serrée.
import time from urllib.parse import quote_plus queries = [ "restaurants in New York", "coffee shops in Austin", "plumbers in Chicago", ] all_places = [] for q in queries: url = f"https://www.google.com/maps/search/{quote_plus(q)}" html = crawl(url) all_places.extend(scrape_html(html)) time.sleep(3) print(f"Collected {len(all_places)} places across {len(queries)} queries")
Crawlbase sert jusqu'à 20 requêtes par seconde par défaut, ce qui offre une marge confortable pour un scraper qui se rythme ; si vous avez vraiment besoin de plus, le support peut l'augmenter. Toute réponse 5XX de l'API est gratuite, donc réessayer une URL bloquée ou indisponible ne vous coûte rien. Le panneau de résultats charge un premier lot de lieux et en révèle davantage au défilement, donc une seule récupération retourne les meilleurs résultats pour une requête ; pour une couverture plus profonde, affinez la requête par quartier plutôt que d'essayer de faire défiler une liste infinie en une seule requête. Pour plus d'informations sur ce schéma, consultez notre guide sur le scraping des listings d'entreprises locales.
Rester non bloqué
Même avec une IP de confiance et le rendu gérés, Google surveille le trafic qui ressemble à celui d'un scraper. Quelques habitudes maintiennent une exécution en bonne santé.
- Rythmez vos requêtes. Marteler Maps dans une boucle serrée est le moyen le plus rapide d'être challengé. Étalez les requêtes et variez vos requêtes plutôt que de paginer un seul terme à pleine vitesse.
- Misez sur la rotation. Un pool d'adresses IP résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels afin qu'aucune ne déclenche une limite. La Crawling API gère cela pour vous ; si vous construisez votre propre infrastructure, c'est la partie à bien maîtriser.
- Lisez les codes de statut. Une exécution qui commence à retourner des murs de consentement ou des CAPTCHA vous indique que le taux ou le niveau d'IP actuel n'est plus suffisant. Traitez cela comme un signal pour reculer, pas du bruit à ignorer.
- Ré-inspectez quand les champs sont vides. Google change périodiquement son balisage. Si les cartes de lieux cessent d'être analysées, ouvrez une page en direct dans les outils de développement et mettez à jour les sélecteurs.
Pour le manuel général, consultez comment scraper des sites web sans être bloqué. Comme le panneau Maps est rendu par JavaScript, notre guide sur le crawling de sites web JavaScript explique pourquoi le rendu est important et comment l'activer. Si votre projet touche également la page de résultats de recherche classique, notre guide sur le scraping des pages de recherche Google couvre cette interface.
Est-il légal de scraper Google Maps ?
Que le scraping de Google Maps soit autorisé dépend des conditions d'utilisation de Google, de votre juridiction et de ce que vous faites avec les données. Les conditions de Google imposent des limites à l'accès automatisé à ses produits, de sorte que le scraping peut aller à l'encontre de ces conditions quelle que soit la prudence de votre outillage. Aucun code ici ne change cela ; il fait simplement fonctionner la partie technique. Lisez les conditions de Google et son robots.txt, et traitez les deux comme la limite de ce que vous collectez.
Quelques lignes à tenir. Ne collectez que les données publiques de listing d'entreprises : les noms, adresses, numéros de téléphone, catégories, notes et nombres d'avis que tout visiteur peut voir sur la carte sans compte. Il s'agit d'informations commerciales publiées pour que les clients puissent trouver un lieu. Ne scrapez pas le contenu des avis individuels, les noms ou profils des évaluateurs, ni toute autre donnée personnelle, et ne redistribuez pas les photos ou autres médias protégés par le droit d'auteur extraits des listings. Maintenez votre volume de requêtes suffisamment bas pour ne pas surcharger les serveurs de Google, et rythmez votre crawl plutôt que de l'exécuter à pleine vitesse.
Si vous avez besoin de données de lieux à grande échelle ou avec une garantie contractuelle, Google propose l'API Places officielle, qui est la voie sanctionnée pour interroger les détails d'entreprises et est le bon chemin pour tout ce qui va au-delà de la recherche légère et publique. Ce guide est délibérément limité aux champs de listing publics visibles sur le panneau de résultats car c'est la ligne qui rend le travail défendable. Données d'entreprises publiques uniquement. Si votre projet a besoin de plus que cela, l'API officielle ou un accord de données est la bonne voie, pas un scraper plus ingénieux.
Points clés
- Le panneau est rendu par JavaScript. Une requête simple obtient un squelette vide, vous avez donc besoin d'un vrai navigateur pour exécuter la page avant que les cartes de lieux existent pour être analysées.
- La Crawling API récupère et rend. Envoyez-lui l'URL Maps avec votre token JavaScript, elle fait tourner des IPs résidentielles et exécute les scripts de la page, et retourne le HTML terminé.
-
BeautifulSoup extrait six champs par carte. Sélectionnez chaque
div[role='article'], puis lisez le nom, la catégorie, l'adresse, le téléphone, la note et le nombre d'avis, et attendez-vous à ce que les noms de classe obfusqués évoluent. - Exportez en JSON et CSV. Un enregistrement par lieu s'intègre directement dans un tableur ou un CRM pour la génération de prospects locaux et la recherche de marché.
- Restez sur les données publiques. Respectez les CGU et le robots.txt de Google, ignorez les avis et les données personnelles, et préférez l'API Places officielle pour tout ce qui est à grande échelle.
Foire aux questions
Pourquoi une requête simple ne retourne-t-elle aucun lieu depuis Google Maps ?
Le panneau de résultats est construit par JavaScript après le chargement de la page, donc un simple requests.get revient avec un squelette principalement vide et aucune des cartes de lieux que vous voyez dans votre navigateur. Google challenge également le trafic qui ne ressemble pas à un vrai navigateur. Récupérer via la Crawling API avec le rendu activé exécute les scripts de la page depuis une IP résidentielle de confiance, de sorte que les cartes de lieux apparaissent dans le HTML que vous récupérez.
Puis-je scraper Google Maps avec Python ?
Oui. Avec requests et BeautifulSoup vous pouvez récupérer une page de résultats rendue et extraire le nom, l'adresse, le téléphone, la catégorie, la note et le nombre d'avis pour chaque lieu. La Crawling API sert de pont qui achemine votre requête vers Google depuis une IP de confiance et rend le JavaScript, de sorte que les requêtes sont traitées normalement plutôt que bloquées. Pour une introduction plus large à Python, consultez notre guide sur le scraping de sites web avec Python.
Quels champs d'entreprise puis-je extraire d'un listing Google Maps ?
Ce tutoriel extrait six champs de chaque carte de lieu : le nom de l'entreprise, la catégorie, l'adresse, le numéro de téléphone, la note en étoiles et le nombre d'avis. Ce sont des champs de listing publics que tout visiteur peut voir sur la carte. Restez dans ces données publiques et évitez le contenu des avis, les profils des évaluateurs ou toute autre donnée personnelle.
Ai-je besoin du rendu JavaScript pour scraper Google Maps ?
Oui. Contrairement à une simple page de résultats de recherche, le panneau de résultats Maps n'existe pas dans le HTML initial ; il est rendu par des scripts dans le navigateur. Utilisez votre token JavaScript Crawlbase pour que la Crawling API rende la page avant de la capturer. Notre guide sur le scraping de pages JavaScript avec Python explique quand le rendu est nécessaire.
Comment scraper Google Maps dans de nombreuses villes ?
Construisez une liste de requêtes de catégorie et de localisation, transformez chacune en URL /maps/search/ et bouclez dessus, en récupérant chacune via la Crawling API et en l'analysant avec la même fonction. Faites une pause de quelques secondes entre les requêtes pour rythmer le crawl plutôt que de le marteler, et collectez les enregistrements dans une liste combinée avant de les exporter.
Existe-t-il une alternative officielle au scraping de Google Maps ?
Oui. L'API Places officielle de Google est la voie sanctionnée pour interroger les détails d'entreprises tels que le nom, l'adresse, le téléphone, la note et les avis, avec un contrat et des quotas derrière elle. Pour tout ce qui va au-delà de la recherche publique légère, ou pour un volume de production, l'API officielle est la bonne voie ; scraper le panneau public convient mieux aux petits travaux respectueux sur des données que tout le monde peut voir sur la carte.
Crawlez n'importe quel site à grande échelle, sans combattre l'infrastructure.
Crawlbase gère les proxies, les empreintes et les CAPTCHA afin que votre équipe livre des pipelines de données au lieu de maintenir la plomberie de crawl. 1 000 requêtes gratuites, sans carte requise.