Scraper les données Google Maps : fiches entreprises et avis

Pourquoi Scrape Google Maps Data ?

Google Maps contient la base de données la plus complète des entreprises locales au monde. Avec plus de 200 millions d'entreprises inscrites, il comprend des noms, adresses, numéros de téléphone, sites Web, évaluations, heures d'ouverture et photos, toutes structurées et consultables.

L'extraction de ces données programmatique permet des applications commerciales précieuses :

• Production de plomb: Établissement de listes ciblées d'entreprises par industrie et emplacement
• Analyse concurrentielle: Carte des emplacements des concurrents, des cotes et du sentiment de révision
• Etude de marché: Comprendre la densité des entreprises, les tarifs et la couverture des services par région
• Vérification locale du référencement: Vérifier les inscriptions de votre entreprise et comparer avec les concurrents
• enrichissement des données: Supplément de données CRM avec des informations commerciales fraîches

Ce guide couvre les approches techniques pour extraire les données de Google Maps à l'aide de proxies. Pour des stratégies plus larges de grattage du SERP, voir notre grattage SERP complet avec guide proxies.

Google Places API vs Scraping

Avant de construire un racleur, considérez si l'API officielle de Google Places répond à vos besoins.

L'API Places est le meilleur choix pour les petites applications critiques de production. Le scraping est plus rentable lorsque vous avez besoin de gros ensembles de données, de texte d'examen complet ou lorsque les coûts de l'API deviennent prohibitifs.

Structure de l'URL Google Maps

Comprendre les modèles d'URL Google Maps est essentiel pour construire un racleur. Il y a deux points d'entrée principaux:

Résultats de la recherche

Les résultats de la recherche Google Maps peuvent être consultés via :

# Browser URL format
https://www.google.com/maps/search/restaurants+near+new+york
# URL parameters for search
https://www.google.com/maps/search/{query}/@{lat},{lng},{zoom}z

Détails du lieu

Les pages d'affaires individuelles suivent ce schéma :

# Place detail URL
https://www.google.com/maps/place/{business+name}/@{lat},{lng},{zoom}z/data=!{place_id}

Construire un cratère Google Maps

Google Maps est une application JavaScript lourde. Contrairement à Google Search, les requêtes HTTP simples renvoient souvent des données incomplètes. Il y a deux approches : analyser les données JSON intégrées à partir de la page source, ou utiliser un navigateur sans tête.

Approche 1: Parsing Embedded JSON (Faster)

Les pages Google Maps contiennent des données structurées intégrées à la source HTML. Voici comment l'extraire :

import requests
import json
import re
import time
import random
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def search_google_maps(query, location="us"):
    """Search Google Maps and extract business listings."""
    proxies = {"http": PROXY_URL, "https": PROXY_URL}
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept": "text/html,application/xhtml+xml",
    }
    # Use the search URL format
    search_url = f"https://www.google.com/maps/search/{query.replace(' ', '+')}"
    response = requests.get(
        search_url,
        headers=headers,
        proxies=proxies,
        timeout=20,
    )
    response.raise_for_status()
    # Extract embedded JSON data from the page
    # Google Maps embeds data in a specific pattern
    businesses = []
    # Look for business data patterns in the response
    # The data is typically in a JavaScript variable
    patterns = re.findall(r'\["([^"]+)",null,null,null,null,null,null,null,"([^"]*)"', response.text)
    # Alternative: parse the structured search results
    # Google Maps returns data in protobuf-like JSON arrays
    json_matches = re.findall(r'null,\["([^"]{5,80})"[^]]*?"([^"]*?(?:St|Ave|Rd|Blvd|Dr|Ln)[^"]*?)"', response.text)
    for match in json_matches[:20]:
        businesses.append({
            "name": match[0],
            "address": match[1] if len(match) > 1 else "",
        })
    return businesses
results = search_google_maps("restaurants near Times Square New York")
for b in results:
    print(f"{b['name']} - {b['address']}")

Approche 2: Navigateur sans tête (plus fiable)

Pour une extraction plus fiable, utilisez un navigateur sans tête qui rend JavaScript :

from playwright.sync_api import sync_playwright
import json
import time
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def scrape_maps_with_browser(query):
    """Use Playwright to scrape Google Maps with full JS rendering."""
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=True,
            proxy={
                "server": "http://gate.proxyhat.com:8080",
                "username": "USERNAME",
                "password": "PASSWORD",
            },
        )
        page = browser.new_page()
        page.set_extra_http_headers({
            "Accept-Language": "en-US,en;q=0.9",
        })
        # Navigate to Google Maps search
        search_url = f"https://www.google.com/maps/search/{query.replace(' ', '+')}"
        page.goto(search_url, wait_until="networkidle", timeout=30000)
        # Wait for results to load
        page.wait_for_selector('div[role="feed"]', timeout=10000)
        # Scroll to load more results
        feed = page.query_selector('div[role="feed"]')
        for _ in range(5):
            feed.evaluate("el => el.scrollBy(0, 1000)")
            time.sleep(1.5)
        # Extract business data from the results
        businesses = []
        items = page.query_selector_all('div[role="feed"] > div > div > a')
        for item in items:
            name = item.get_attribute("aria-label")
            href = item.get_attribute("href")
            if name and href:
                businesses.append({
                    "name": name,
                    "url": href,
                })
        browser.close()
        return businesses
results = scrape_maps_with_browser("coffee shops in San Francisco")
for b in results:
    print(f"{b['name']}")
    print(f"  {b['url'][:80]}...")
    print()

Extraire des détails commerciaux

Une fois que vous avez une liste des URL d'affaires, extraire des informations détaillées de chaque liste:

import requests
import re
import json
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def extract_business_details(maps_url):
    """Extract detailed business info from a Google Maps place page."""
    proxies = {"http": PROXY_URL, "https": PROXY_URL}
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
    }
    response = requests.get(maps_url, headers=headers, proxies=proxies, timeout=20)
    text = response.text
    business = {}
    # Extract business name
    name_match = re.search(r'

Stratégie de proxy pour Google Maps

Google Maps a ses propres protections anti-bot qui nécessitent une stratégie de proxy sur mesure.

Pourquoi les procurations résidentielles sont nécessaires

Google Maps est particulièrement agressif sur le blocage des IP de datacenter. L'application charge des données via plusieurs appels API, et Google recoupe l'IP pour toutes ces requêtes. Proxies résidentielles de ProxyHat sont essentiels parce que:

• Ils passent des contrôles de réputation IP que les appels API Maps font appliquer
• Ils appuient la géo-ciblage au niveau de la ville pour des recherches spécifiques à un lieu donné
• Ils maintiennent le comportement de session cohérent que Maps attend

Gestion des séances

Contrairement au raclage SERP régulier où vous faites pivoter les IP par demande, Google Maps fonctionne mieux avec des sessions collantes:

# For Google Maps, use sticky sessions (same IP for a business detail page)
# ProxyHat supports session-based rotation via the proxy URL
# See docs.proxyhat.com for session configuration
# Rotating IP (for search listings)
ROTATING_PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
# Sticky session (for individual place pages)
# Same session ID = same IP for the session duration
STICKY_PROXY = "http://USERNAME-session-maps123:PASSWORD@gate.proxyhat.com:8080"

Limite des taux

Google Maps est plus sensible aux demandes rapides que Google Search. Suivez ces lignes directrices :

• Attendez 5-10 secondes entre les pages de résultats de recherche
• Attendez 3-5 secondes entre les chargements individuels de page place
• Limiter les demandes simultanées pour éviter les éclatements
• Utiliser des délais plus longs pour examiner la pagination (8-15 secondes entre les pages)

Mise en œuvre de Node.js

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
async function searchGoogleMaps(query) {
  const searchUrl = `https://www.google.com/maps/search/${encodeURIComponent(query)}`;
  const { data } = await axios.get(searchUrl, {
    headers: {
      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Accept-Language': 'en-US,en;q=0.9',
    },
    httpsAgent: agent,
    timeout: 20000,
  });
  // Extract business names from the response
  const businesses = [];
  const namePattern = /\["([^"]{3,80})",null,null,null,null,null,null,null/g;
  let match;
  while ((match = namePattern.exec(data)) !== null) {
    businesses.push({ name: match[1] });
  }
  return businesses;
}
async function main() {
  const results = await searchGoogleMaps('plumbers in Chicago');
  console.log(`Found ${results.length} businesses:`);
  results.forEach((b, i) => console.log(`${i + 1}. ${b.name}`));
}
main().catch(console.error);

Extraction des examens à l'échelle

Les revues Google Maps sont parmi les points de données les plus précieux. Chaque examen comprend le nom de l'évaluateur, la cote, le texte, la date et parfois les photos.

import requests
import re
import json
import time
import random
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def extract_reviews(place_id, num_reviews=50):
    """Extract reviews for a Google Maps place using the internal API."""
    proxies = {"http": PROXY_URL, "https": PROXY_URL}
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Accept-Language": "en-US,en;q=0.9",
    }
    reviews = []
    # Google Maps loads reviews via AJAX with pagination tokens
    # The first page is loaded with the place page
    maps_url = f"https://www.google.com/maps/place/?q=place_id:{place_id}"
    response = requests.get(maps_url, headers=headers, proxies=proxies, timeout=20)
    # Extract review data from embedded JSON
    # Reviews are typically in arrays with rating, text, and author
    review_pattern = re.findall(
        r'"(\d)","([^"]{10,500})"[^]]*?"([^"]{2,50})"',
        response.text
    )
    for match in review_pattern[:num_reviews]:
        reviews.append({
            "rating": int(match[0]),
            "text": match[1],
            "author": match[2],
        })
    return reviews
# Example: extract reviews
reviews = extract_reviews("ChIJN1t_tDeuEmsRUsoyG83frY4")  # Example place ID
for r in reviews[:5]:
    print(f"{'*' * r['rating']} by {r['author']}")
    print(f"  {r['text'][:100]}...")
    print()

Structure et stockage des données

Organiser les données de Google Maps dans un format structuré pour l'analyse :

import json
import csv
from datetime import datetime
def save_businesses(businesses, output_format="json"):
    """Save scraped business data in structured format."""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    if output_format == "json":
        filename = f"maps_data_{timestamp}.json"
        with open(filename, "w") as f:
            json.dump(businesses, f, indent=2, ensure_ascii=False)
    elif output_format == "csv":
        filename = f"maps_data_{timestamp}.csv"
        if businesses:
            keys = businesses[0].keys()
            with open(filename, "w", newline="", encoding="utf-8") as f:
                writer = csv.DictWriter(f, fieldnames=keys)
                writer.writeheader()
                writer.writerows(businesses)
    print(f"Saved {len(businesses)} businesses to {filename}")
    return filename

Considérations juridiques et éthiques

Le filtrage des données Google Maps soulève d'importantes questions juridiques et éthiques :

• Conditions d'utilisation de Google: Google's ToS interdit le grattage automatisé. Envisager d'utiliser l'API Lieux pour les applications de production
• Protection des données: Les données commerciales comme les numéros de téléphone et les adresses peuvent faire l'objet de réglementations en matière de protection des données dans certaines juridictions.
• Taux limite: Même avec les proxies, être respectueux de l'infrastructure de Google. Le grattage excessif affecte la qualité du service
• Freinage des données: Toujours rythmez vos données et rafraîchissez-les régulièrement, car les informations d'affaires changent fréquemment

Pour les applications essentielles à la mission, envisagez de combiner l'API des lieux officiels pour les données de base avec le grattage ciblé pour les champs supplémentaires comme le texte de révision. Cette approche hybride équilibre la conformité avec l'exhaustivité des données.

Pour en savoir plus sur les meilleures pratiques de grattage sur le Web, consultez notre guide complet sur les proxies de raclage de toile, et apprendre à éviter les blocs dans notre guide anti-blocage. Consultez le Documentation ProxyHat pour les détails de configuration de proxy.