Scraper Google Maps avec Python et Sélénium : Guide complet

Vous avez besoin d'extraire les coordonnées de 500 restaurants, les emails de plombiers locaux, ou les avis clients d'une région ? Google Maps contient ces données, mais les télécharger manuellement prend des heures.

C'est là que Python et Sélénium entrent en jeu. Ces deux outils permettent d'automatiser l'extraction de données depuis Google Maps — mais ils demandent du temps, des compétences en programmation, et posent des défis techniques importants.

Cet article vous montre comment fonctionnent Python et Sélénium pour le scraping, les étapes concrètes pour démarrer, les pièges à éviter, et surtout : quand une approche manuelle n'est pas la bonne solution.

---

Pourquoi Python et Sélénium pour Google Maps ?

Google Maps n'est pas une simple page HTML statique. Les résultats se chargent dynamiquement : vous tapez une recherche, des fiches apparaissent progressivement, vous scrollez, d'autres résultats se chargent. C'est du JavaScript en action.

Trois outils peuvent extraire ces données :

1. BeautifulSoup ou Requests Ces bibliothèques Python récupèrent le code HTML brut d'une page. Problème : elles ne peuvent pas exécuter du JavaScript. Sur Google Maps, vous obtenez une page vide.

2. Sélénium Sélénium lance un vrai navigateur (Chrome, Firefox) et simule les clics, scrolls, et interactions humaines. Le JavaScript s'exécute. Vous pouvez attendre que les résultats se chargent, puis les extraire. C'est lent, mais ça marche.

3. Puppeteer ou Playwright Outils similaires à Sélénium, plus rapides, mais moins documentés pour les débutants.

Pourquoi choisir Python + Sélénium ? - Python est facile à apprendre et très documenté - Sélénium fonctionne avec tous les navigateurs - Combinés, ils gèrent les pages dynamiques sans API - Vous avez un contrôle total sur ce que vous extrayez

Limitation clé : c'est lent. Extraire 1 000 résultats peut prendre 2-3 heures. Et vous risquez des blocages IP, des CAPTCHA, ou des bans temporaires.

---

Prérequis techniques : ce qu'il faut installer

Avant d'écrire une seule ligne de code, installez ces outils.

1. Python (version 3.8 ou plus récente)

Téléchargez depuis python.org. Pendant l'installation, cochez "Add Python to PATH" — c'est crucial pour utiliser Python en ligne de commande.

Vérifiez l'installation :

python --version

Vous devez voir Python 3.x.x.

2. Sélénium

Ouvrez votre terminal ou invite de commande et tapez :

pip install selenium

Pip (Python Package Manager) télécharge et installe Sélénium automatiquement.

3. WebDriver pour votre navigateur

Sélénium ne peut pas contrôler un navigateur sans un pilote (WebDriver). Le choix le plus courant est Chrome.

Pour Chrome : - Téléchargez ChromeDriver (doit correspondre à votre version de Chrome) - Décompressez le fichier - Notez le chemin complet du fichier chromedriver (ex: /Users/nom/Downloads/chromedriver)

Alternative simple : installez webdriver-manager pour éviter de gérer les versions manuellement :

pip install webdriver-manager

4. Bibliothèques supplémentaires

Pour traiter et exporter les données :

pip install pandas requests beautifulsoup4

• Pandas : organise les données en tableaux (DataFrames)
• Requests : fait des requêtes HTTP (optionnel ici, mais utile)
• BeautifulSoup : analyse le HTML (optionnel)

Vérifiez que tout fonctionne :

python -c "import selenium; print(selenium.__version__)"

Vous devez voir un numéro de version (ex: 4.15.2).

---

Anatomie d'un script Sélénium pour Google Maps

Voici la structure générale d'un script de scraping Google Maps :

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 webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.service import Service
import time
import pandas as pd

# 1. Lancer le navigateur
service = Service(ChromeDriverManager().install())
driver = webdriver.Chrome(service=service)

# 2. Accéder à Google Maps
driver.get("https://www.google.com/maps")

# 3. Rechercher un terme
search_box = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "searchboxinput"))
)
search_box.send_keys("Restaurants Paris")
search_box.send_keys(Keys.ENTER)

# 4. Attendre les résultats
time.sleep(3)

# 5. Extraire les données
results = []
result_elements = driver.find_elements(By.CLASS_NAME, "Nv2PK")

for element in result_elements:
    try:
        name = element.find_element(By.CLASS_NAME, "NrjWb").text
        results.append({"name": name})
    except:
        pass

# 6. Exporter en CSV
df = pd.DataFrame(results)
df.to_csv("restaurants.csv", index=False)

# 7. Fermer le navigateur
driver.quit()

Décortiquons chaque étape.

---

Étape 1 : Lancer le navigateur

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

service = Service(ChromeDriverManager().install())
driver = webdriver.Chrome(service=service)

webdriver-manager télécharge automatiquement la bonne version de ChromeDriver. Vous n'avez rien à faire manuellement.

Alternative sans webdriver-manager (si vous avez téléchargé ChromeDriver manuellement) :

driver = webdriver.Chrome("/chemin/vers/chromedriver")

---

Étape 2 : Accéder à Google Maps et rechercher

driver.get("https://www.google.com/maps")

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Attendre que la barre de recherche soit visible
search_box = WebDriverWait(driver, 10).until(
    EC.presence_of_element_located((By.ID, "searchboxinput"))
)

# Taper la recherche
search_box.send_keys("Plombiers Lyon")

# Appuyer sur Entrée
from selenium.webdriver.common.keys import Keys
search_box.send_keys(Keys.ENTER)

# Attendre que les résultats se chargent
time.sleep(3)

Pourquoi WebDriverWait ? Google Maps charge les éléments dynamiquement. Si vous essayez de trouver la barre de recherche avant qu'elle n'existe, le script plante. WebDriverWait attend jusqu'à 10 secondes que l'élément apparaisse.

---

Étape 3 : Extraire les noms et adresses

# Trouver tous les résultats (chaque résultat est une fiche business)
result_elements = driver.find_elements(By.CLASS_NAME, "Nv2PK")

results = []

for element in result_elements:
    try:
        # Nom du business
        name = element.find_element(By.CLASS_NAME, "NrjWb").text

        # Adresse
        address = element.find_element(By.CLASS_NAME, "Xs85Hc").text

        # Note (optionnel)
        try:
            rating = element.find_element(By.CLASS_NAME, "MW4etd").text
        except:
            rating = "N/A"

        results.append({
            "name": name,
            "address": address,
            "rating": rating
        })
    except Exception as e:
        print(f"Erreur : {e}")
        continue

print(f"Extrait {len(results)} résultats")

Sélecteurs CSS : By.CLASS_NAME trouve des éléments par leur classe CSS. Les noms de classe (Nv2PK, NrjWb) changent régulièrement chez Google. Si le script ne marche pas, ouvrez l'inspecteur (F12) et trouvez les bonnes classes.

---

Étape 4 : Gérer la pagination

Google Maps affiche environ 20 résultats par page. Pour en avoir plus, vous devez scroller vers le bas de la liste.

# Trouver le conteneur des résultats
results_container = driver.find_element(By.CLASS_NAME, "m6QErb")

# Scroller 5 fois (chaque scroll charge ~20 résultats supplémentaires)
for _ in range(5):
    driver.execute_script(
        "arguments[0].scrollTop = arguments[0].scrollHeight",
        results_container
    )
    time.sleep(2)  # Attendre que les résultats se chargent

# Extraire TOUS les résultats (maintenant que vous avez scrollé)
all_results = driver.find_elements(By.CLASS_NAME, "Nv2PK")

Attention : scroller 5 fois = ~100 résultats. Scroller 20 fois = 400+ résultats et 2-3 minutes. C'est lent.

---

Étape 5 : Extraire les coordonnées (latitude/longitude)

Google Maps stocke les coordonnées GPS dans l'URL. Vous pouvez les récupérer en cliquant sur une fiche.

results = []

for element in result_elements:
    try:
        name = element.find_element(By.CLASS_NAME, "NrjWb").text

        # Cliquer sur le résultat pour ouvrir la fiche détaillée
        element.click()
        time.sleep(1)

        # Récupérer l'URL (elle contient les coordonnées)
        current_url = driver.current_url
        # Format: https://www.google.com/maps/place/.../@48.8566,2.3522,...

        results.append({
            "name": name,
            "url": current_url
        })
    except Exception as e:
        print(f"Erreur : {e}")

Les coordonnées sont dans l'URL après /@ (latitude, longitude).

---

Étape 6 : Exporter les données en CSV

import pandas as pd

# Convertir en DataFrame
df = pd.DataFrame(results)

# Exporter en CSV
df.to_csv("resultats_google_maps.csv", index=False, encoding="utf-8")

print(f"✓ {len(results)} résultats exportés dans resultats_google_maps.csv")

Ouvrez le fichier CSV dans Excel ou Google Sheets.

---

Étape 7 : Fermer le navigateur

driver.quit()

Toujours fermer le navigateur pour libérer la mémoire.

---

Script complet : exemple concret

Voici un script fonctionnel pour extraire les restaurants d'une ville :

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.chrome.service import Service
import time
import pandas as pd

# Lancer le navigateur
service = Service(ChromeDriverManager().install())
driver = webdriver.Chrome(service=service)

try:
    # Accéder à Google Maps
    driver.get("https://www.google.com/maps")

    # Rechercher des restaurants
    search_box = WebDriverWait(driver, 10).until(
        EC.presence_of_element_located((By.ID, "searchboxinput"))
    )
    search_box.send_keys("Restaurants Marseille")
    search_box.send_keys(Keys.ENTER)

    time.sleep(3)

    # Scroller pour charger plus de résultats
    results_container = driver.find_element(By.CLASS_NAME, "m6QErb")
    for _ in range(3):
        driver.execute_script(
            "arguments[0].scrollTop = arguments[0].scrollHeight",
            results_container
        )
        time.sleep(2)

    # Extraire les données
    results = []
    result_elements = driver.find_elements(By.CLASS_NAME, "Nv2PK")

    for element in result_elements[:50]:  # Limiter à 50 pour tester
        try:
            name = element.find_element(By.CLASS_NAME, "NrjWb").text
            address = element.find_element(By.CLASS_NAME, "Xs85Hc").text

            results.append({
                "name": name,
                "address": address
            })
        except:
            pass

    # Exporter
    df = pd.DataFrame(results)
    df.to_csv("restaurants_marseille.csv", index=False, encoding="utf-8")

    print(f"✓ {len(results)} restaurants extraits")

finally:
    driver.quit()

Exécutez-le :

python scraper.py

Un navigateur Chrome s'ouvre, effectue la recherche, et exporte les résultats.

---

Les vrais défis du scraping Google Maps

Le script fonctionne sur votre ordinateur. Mais à grande échelle, vous rencontrez des problèmes.

1. Blocage par IP

Après 50-100 requêtes depuis la même IP, Google vous bloque temporairement. Vous voyez un CAPTCHA ou une page d'erreur.

Solutions : - Ajouter des délais aléatoires entre les requêtes (time.sleep(random.randint(2, 5))) - Utiliser des proxies ou un VPN - Répartir les requêtes sur plusieurs jours

2. CAPTCHA

Google peut afficher un CAPTCHA pour vérifier que vous êtes humain. Sélénium ne peut pas le résoudre automatiquement (sans outils externes payants).

Solutions : - Accepter que certaines requêtes échouent - Utiliser des services de résolution de CAPTCHA (cher et lent) - Scraper avec modération

3. Sélecteurs CSS qui changent

Google modifie régulièrement ses classes CSS. Nv2PK d'aujourd'hui peut devenir Abc123 demain. Votre script casse.

Solutions : - Utiliser des sélecteurs XPath plus stables (plus complexes) - Vérifier et mettre à jour le script tous les mois - Monitorer les erreurs

4. Performance

Extraire 1 000 résultats = 50+ minutes. Extraire 10 000 = 8+ heures. C'est très lent comparé aux outils automatisés.

5. Données incomplètes

Vous obtenez les noms et adresses. Mais les emails, les numéros de téléphone, les avis, les technologies utilisées ? Vous devez cliquer sur chaque fiche, attendre qu'elle se charge, puis extraire. C'est encore plus lent.

6. Conformité légale

Google Maps ToS interdisent le scraping automatisé. Vous ne risquez pas de poursuites, mais votre compte peut être banni, ou votre IP bloquée définitivement.

---

Quand Python + Sélénium n'est PAS la bonne solution

Sélénium est puissant, mais ce n'est pas l'outil idéal pour :

Extraire > 500 résultats régulièrement Trop lent, trop de risques de blocage.

Avoir des emails, téléphones, avis, technos Sélénium peut le faire, mais il faudrait cliquer sur chaque fiche. 1 000 fiches = 2-3 jours de scraping.

Données à jour mensuellement Vous devrez relancer le script chaque mois. Risque de blocage à chaque exécution.

Besoin de données enrichies Les données brutes de Google Maps manquent d'informations métier.

Pas de compétences en code Python + Sélénium demandent du debugging, de la maintenance, des mises à jour.

---

IBLead : l'alternative sans code

Si vous avez besoin d'extraire rapidement des données de Google Maps sans scraper, il existe une autre approche : utiliser une base de données pré-indexée.

IBLead est une base de données de 50M+ businesses Google Maps (France, Belgique, Suisse, Canada, États-Unis, et 10+ autres pays). Les données sont mises à jour mensuellement — pas besoin de scraper.

Vous recherchez par ville, région, catégorie, puis exportez en CSV avec : - Noms, adresses, téléphones - Emails (enrichis depuis le site web) - Avis Google (texte complet, notes, dates, auteurs) — exclusif - Technologies détectées (WordPress, Shopify, HubSpot, etc.) — exclusif - Réseaux sociaux, horaires, coordonnées GPS

Comparaison : Python + Sélénium vs IBLead