Google Maps Daten scrapen: Geschäftseinträge und Bewertungen

Warum Scrape Google Maps Daten?

Google Maps enthält die umfassendste Datenbank der lokalen Unternehmen der Welt. Mit mehr als 200 Millionen Unternehmen aufgelistet, umfasst es Namen, Adressen, Telefonnummern, Websites, Bewertungen, Bewertungen, Betriebsstunden und Fotos — alle strukturiert und durchsuchbar.

Diese Daten programmtechnisch zu extrahieren ermöglicht wertvolle Geschäftsanwendungen:

• Bleierzeugung: Erstellen Sie gezielte Listen von Unternehmen nach Industrie und Standort
• Wettbewerbsanalyse: Karte Wettbewerber Standorte, Bewertungen und Einschätzung Stimmung
• Marktforschung: Verstehen Sie Geschäftsdichte, Preismuster und Serviceabdeckung nach Bereichen
• Lokales SEO Auditing: Verifizieren Sie Ihre Business-Listen und vergleichen Sie mit Wettbewerbern
• Datenanreicherung: Ergänzung CRM-Daten mit frischen Geschäftsinformationen

Diese Anleitung deckt die technischen Ansätze ab, um Daten von Google Maps mit Proxies zu extrahieren. Für breitere SERP-Schrottstrategien siehe unsere komplettes SERP-Schrotten mit Proxies-Führung.

Google Places API vs Scraping

Bevor Sie einen Abstreifer bauen, prüfen Sie, ob die offizielle Google Places API Ihren Bedürfnissen entspricht.

Die Places API ist die beste Wahl für kleine, produktionskritische Anwendungen. Scraping ist kostengünstiger, wenn Sie große Datensätze, Vollständige Überprüfung Text oder wenn API-Kosten zu verbieten.

Google Maps URL Struktur

Das Verständnis von Google Maps URL-Mustern ist für den Aufbau eines Abstreifers unerlässlich. Es gibt zwei Haupteintrittspunkte:

Suchergebnisse

Google Maps Suchergebnisse können über:

# 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

Details zum Thema

Einzelne Geschäftsseiten folgen diesem Muster:

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

Erstellen eines Google Maps Scraper

Google Maps ist eine JavaScript-heavy Anwendung. Im Gegensatz zur regelmäßigen Google-Suche geben einfache HTTP-Anfragen häufig unvollständige Daten zurück. Es gibt zwei Ansätze: Parsing der eingebetteten JSON-Daten aus Seitenquelle, oder mit einem kopflosen Browser.

Ansatz 1: Parsing Embedded JSON (Faster)

Google Maps Seiten enthalten strukturierte Daten, die in der HTML-Quelle eingebettet sind. Hier ist, wie man es extrahiert:

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']}")

Ansatz 2: Headless Browser (Mehr zuverlässig)

Für eine zuverlässigere Extraktion verwenden Sie einen kopflosen Browser, der JavaScript macht:

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()

Extrahieren von Business Details

Sobald Sie eine Liste von Business-URLs haben, extrahieren Sie detaillierte Informationen aus jeder 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'

Proxy-Strategie für Google Maps

Google Maps hat eigene Anti-Bot-Schutz, die eine maßgeschneiderte Proxy-Strategie erfordern.

Warum wohnhafte Proxies erforderlich sind

Google Maps ist besonders aggressiv gegenüber der Blockierung von Datacenter-IPs. Die Anwendung lädt Daten durch mehrere API-Anrufe und Google kreuzt die IP über alle diese Anfragen. Residential Proxis aus ProxyHat sind wichtig, weil:

• Sie übergeben IP-Reputationsüberprüfungen, die Karten API Anrufe durchsetzen
• Sie unterstützen geo-targeting auf Stadtebene für ortsspezifische Suchanfragen
• Sie halten das konsistente Sitzungsverhalten, das Karten erwarten

Sitzungsmanagement

Im Gegensatz zum regelmäßigen SERP-Schrott, bei dem Sie IPs pro Anfrage drehen, funktioniert Google Maps mit klebrigen Sitzungen besser:

# 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"

Grenzwerte

Google Maps ist empfindlicher auf schnelle Anfragen als regelmäßige Google-Suche. Folgen Sie diesen Richtlinien:

• Warten Sie 5-10 Sekunden zwischen den Suchergebnisseiten
• Warten Sie 3-5 Sekunden zwischen einzelnen Ortsseitenlasten
• Beschränken Sie gleichzeitig Anfragen, um Burstmuster zu vermeiden
• Verwenden Sie längere Verzögerungen bei der Überprüfung Pagination (8-15 Sekunden zwischen Seiten)

Node.js Implementierung

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);

Bewertungen bei Scale extrahieren

Google Maps Bewertungen gehören zu den wertvollsten Datenpunkten. Jede Bewertung enthält den Rezensionsnamen, die Bewertung, den Text, das Datum und manchmal die Fotos.

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()

Datenstrukturierung und Speicherung

Veranstalten Sie Daten von Google Maps in ein strukturiertes Format zur 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

Rechtliche und ethische Überlegungen

Die Daten von Google Maps erheben wichtige rechtliche und ethische Fragen:

• Google Nutzungsbedingungen: Googles ToS verbieten automatisiertes Abkratzen. Betrachten Sie die Verwendung der offiziellen Places API für Produktionsanwendungen
• Datenschutz: Geschäftsdaten wie Telefonnummern und Adressen können in einigen Gerichtsbarkeiten Datenschutzbestimmungen unterliegen
• Grenzwerte: Auch mit Proxies, seien Sie respektvoll von Googles Infrastruktur. Übermäßiges Abkratzen beeinträchtigt die Servicequalität
• Datenfrische: Aktualisieren Sie Ihre Daten immer und aktualisieren Sie sie regelmäßig, da sich Geschäftsinformationen häufig ändern

Für unternehmenskritische Anwendungen, betrachten Sie die Kombination der offiziellen Places API für Kerndaten mit gezielter Abstreifung für Zusatzfelder wie Reviewtext. Dieser hybride Ansatz bilanziert die Einhaltung der Datenvollständigkeit.

Für mehr über Web-Schrott Best Practices, siehe unsere komplette Führung für Bahnabstreifer, und lernen, Blöcke in unserer Antiblockierführung. Beraten Sie die ProxyHat Dokumentation für Proxy Konfigurationsdetails.