Wie man Google Maps für Bewertungen scrapen kann: Eine praktische Python-Anleitung

Wenn Sie schon einmal versucht haben, Google Maps in nennenswertem Umfang nach Bewertungen zu scrapen, kennen Sie die Probleme bereits: Die offizielle Places-API gibt höchstens eine Handvoll Bewertungen pro Ort zurück, JavaScript rendert den Großteil des Eintrags, und die CSS-Klassen-Hooks wechseln so oft, dass ein Scraper zwischen Freitag und Montag ausfällt. Die gute Nachricht ist, dass die Daten erreichbar sind – man muss nur das richtige Werkzeug für die Aufgabe auswählen.

Dieser Leitfaden richtet sich an Python-Entwickler, Datenanalysten und Wachstumsteams, die Unternehmensbewertungen aus Google Maps für Stimmungsanalysen, Wettbewerbsforschung, Standortanalysen oder die Lead-Generierung nutzen möchten. Wir werden drei Methoden parallel behandeln: Selenium plus einen Proxy für vollständige Kontrolle, eine Scraping-API mit Render-Anweisungen für einen Low-Code-Ansatz und eine JSON-API pro Bewertung, wenn Sie saubere, strukturierte Felder wie review_id, iso_date_of_last_editund Antworten des Inhabers.

Am Ende erhalten Sie funktionierenden Code, eine Vergleichstabelle zur Begründung Ihres gewählten Ansatzes und eine kurze Pipeline zur Bereinigung und Analyse Ihrer gesammelten Daten. Wo bekannt ist, dass die zugrunde liegenden Selektoren oder Quoten schwanken, weist der Artikel darauf hin, damit Sie entsprechend planen können, anstatt um 2 Uhr morgens Fehler beheben zu müssen.

Bewertungen gehören zu den aussagekräftigsten Datensätzen im öffentlichen Web. Ein sauberer Maps-Bewertungs-Feed ermöglicht es Ihnen, das Kundenerlebnis eines Mitbewerbers zu benchmarken, die Reputation über Standorte hinweg zu überwachen, standortbezogene Lead-Listen zu erstellen, einen regionalen Stimmungsindex zu berechnen oder ein Empfehlungsmodell anhand echter menschlicher Kommentare zu trainieren. Nichts davon funktioniert, wenn Sie nur Stern-Durchschnittswerte haben – und genau dabei hören die meisten generischen Listing-Scraper auf.

Realistisch betrachtet lassen sich die Felder, die Sie aus Google Maps extrahieren können, in zwei Ebenen unterteilen. Auf der Eintragsebene erhalten Sie Ortsname, Adresse, Gesamtbewertung, Anzahl der Bewertungen, Kategorie, Öffnungszeiten, Telefonnummer und Serviceoptionen wie „Im Restaurant essen“ oder „Lieferung“. Auf der Ebene der einzelnen Bewertungen erhalten Sie den Bewertungstext (das Snippet), den Namen des Bewerters, den Profil-Link, die Sternebewertung, das Bewertungsdatum oder das Datum der letzten Bearbeitung, Foto-URLs, eine Antwort des Inhabers (falls vorhanden) sowie Themen-Tags wie „Service“ oder „Atmosphäre“. Wenn Sie diese Aufteilung im Voraus kennen, können Sie entscheiden, ob das Scraping auf Listing-Ebene ausreicht oder ob Sie einzelne Bewertungen genauer untersuchen müssen. Für Anwendungsfälle wie Marktforschung und Bewertungsüberwachung ist fast immer die zweite Ebene erforderlich.

Wenn Sie recherchieren, wie man Google Maps nach Bewertungen durchsucht, ergeben sich drei Möglichkeiten. Die Wahl der falschen Option ist der häufigste Grund, warum Teams auf halbem Weg aufgeben. Nehmen Sie sich daher hier ein paar Minuten Zeit, bevor Sie Code schreiben.

Die offizielle Google Places-API ist rechtlich gesehen die sauberste Lösung, sie ist jedoch für App-Integrationen konzipiert, nicht für Analysen. Laut Googles Dokumentation liefern Anfragen nach Ortsdetails nur eine kleine, begrenzte Teilmenge der in der Maps-Benutzeroberfläche angezeigten Bewertungen zurück, was sie für Sentiment-Bewertungen in jeglichem Umfang ungeeignet macht. Ein selbst erstellter Selenium-Scraper in Kombination mit einem Residential-Proxy gibt Ihnen volle Kontrolle und die gleiche Ansicht, die ein nicht angemeldeter Nutzer sehen würde – allerdings auf Kosten des Betriebs eines Browsers und der Verfolgung von CSS-Änderungen. Eine Scraping-API in der Mitte übernimmt die Proxy-Rotation, die CAPTCHA-Verarbeitung und das Headless-Rendering, und eine JSON-API pro Bewertung darüber hinaus übernimmt zudem das Parsing.

Verwenden Sie die folgende Tabelle als Entscheidungshilfe.

Maps ist schwieriger zu scrapen als eine typische E-Commerce-Website, und zwar nicht aus den Gründen, die man erwarten würde. Als Erstes stößt man auf die Cookie-Einwilligungswand, die das Rendern des Suchergebnisfensters blockiert, bis sie geschlossen wird. Zweitens ist Maps eine reine JavaScript-Anwendung, sodass ein einfacher requests.get eine fast leere Hülle zurück. Das dritte Problem, das Scraper am häufigsten zum Scheitern bringt, ist, dass der Eintrag-Bereich scrollgesteuertes Laden anstelle von paginierten URLs verwendet. Es gibt keine ?page=2 , auf den man zugreifen kann.

Darüber hinaus verschleiert und rotiert Google CSS-Klassennamen. Hooks wie hfpxzc, MW4etd, UY7F9und Nv2PK waren zum Zeitpunkt der Erstellung dieses Artikels gültig, sollten jedoch vor der Veröffentlichung oder Ausführung erneut überprüft werden, da sie sich häufig ändern. Aggressive Anfragemuster von einer einzelnen IP-Adresse führen zudem zu Ratenbeschränkungen und gelegentlichen reCAPTCHA-Abfragen, weshalb ein Pool aus privaten Proxys und zufällige Wartezeiten unverzichtbar sind, sobald man mehr als eine Handvoll Abfragen durchführt.

Sie benötigen Python 3.10 oder neuer und eine aktuelle Chrome-Installation. Der Selenium-Track benötigt zudem einige Pakete. Installieren Sie diese mit pip:

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

Jedes davon hat seinen Nutzen. Selenium steuert den Browser. Selenium Wire ist eine schlanke Erweiterung, die die zugrunde liegenden HTTP-Anfragen offenlegt, sodass Sie einen authentifizierten Proxy einbinden können, ohne mit Chrome-Flags jonglieren zu müssen. Webdriver Manager verwaltet die ChromeDriver-Binärdatei, sodass Sie nicht auf jedem Laptop eine bestimmte Version festlegen müssen. BeautifulSoup mit dem lxml-Backend parst das gerenderte HTML, und requests reicht für die API-Tracks aus.

Für die Methoden 2 und 3 registrieren Sie sich bitte für ein SERP-API-Konto, bevor Sie beginnen. In der Regel erhalten Sie ein kostenloses Guthaben zum Testen; geben Sie den Schlüssel anschließend in die unten stehenden Code-Blöcke ein.

Die klassische Lösung, um Bewertungen aus Google Maps zu scrapen, ist ein echter Browser in Kombination mit einem rotierenden Residential-Proxy. Dies ist der Ansatz mit dem größten Umfang und der größten Kontrolle. Sie starten eine Chrome-Instanz, leiten deren Datenverkehr über den Proxy, scrollen im Fenster, bis genügend Einträge geladen sind, und analysieren den Quellcode der Seite mit BeautifulSoup. Dies ist die richtige Wahl, wenn Sie Flexibilität benötigen (benutzerdefinierte Klickabläufe, Screenshot-Erfassung, hinter einer Anmeldung verborgene Unternehmensprofile) oder Ihr Umfang klein genug ist, um Selektoren manuell zu verwalten. Die folgenden fünf Unterabschnitte führen Sie Schritt für Schritt durch den gesamten Prozess, mit Code, den Sie direkt in ein Skript einfügen können.

Der Trick beim Scrapen von Google Maps-Bewertungen mit Selenium besteht darin, jede Anfrage über einen rotierenden Residential-Proxy zu senden. Reines Selenium kann HTTP-Basic-Auth-Anmeldedaten nicht sauber weiterleiten – hier kommt Selenium Wire ins Spiel. Es stellt den Proxy-Block in seleniumwire_options und übernimmt den Authentifizierungs-Handshake im Hintergrund. Das von den meisten Anbietern erwartete Proxy-URL-Muster sieht wie folgt aus http://<username>:<password>@<host>:<port>, mit zusätzlichen Parametern wie render oder country_code , die an den Benutzernamen angehängt werden. Überprüfen Sie das genaue Format anhand der aktuellen Dokumentation Ihres Anbieters, bevor Sie dies in der Produktion ausführen, da die URL-Konventionen variieren.

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)

Der Headless-Modus hält den Speicherverbrauch auf Servern niedrig, und die implizite Wartezeit von 30 Sekunden gibt Maps Zeit zum Rendern, bevor Selektor-Lookups ausgelöst werden. Wenn du eine ausführlichere Einführung in Selenium suchst, führen die Dokumentationen zu den Sprachbindungen detailliert durch alle Optionen.

Sobald der Treiber eingerichtet ist, richten Sie ihn auf eine Such-URL wie https://www.google.com/maps/search/pizza+in+new+york. Maps zeigt normalerweise beim ersten Laden einer Sitzung einen Cookie-Einwilligungsdialog an, und das Layout lässt Sie nicht durch die Ergebnisse scrollen, bis Sie diesen schließen. Umschließen Sie den Klick mit einem try/except, da proxy-gerenderter Datenverkehr in einigen Regionen den Dialog komplett überspringt.

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.")

Protokollieren Sie den Fehler immer, anstatt die Ausnahme weiterzuleiten. Der Lauf soll fortgesetzt werden, wenn der Dialog fehlt, und nicht abgebrochen werden. Wenn Ihre Ländereinstellung eine andere Schaltflächenbeschriftung anzeigt, tauschen Sie den XPath-Text aus oder greifen Sie auf einen aria-label Übereinstimmung mit dem Einwilligungsbanner zurück.

Maps paginiert nicht. Wenn du im linken Bereich scrollst, werden weitere Einträge in das DOM gestreamt, bis schließlich ein Endmarker erreicht wird. Um Bewertungen aus Google Maps in einem vernünftigen Umfang zu extrahieren, musst du das Scrollen selbst steuern. Zwei Muster funktionieren gut. Das erste verwendet Tastenanschläge über ActionChains, was sich wie ein echter Nutzer anfühlt. Das zweite nutzt einen JavaScript-Executor, der schneller ist, aber leichter identifiziert werden kann.

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)

Optimieren presses und pause_time an Ihre Zielabfrage an. Fünf Seiten-nach-unten-Bewegungen mit einer Pause von einer Sekunde sind ein vernünftiger Ausgangspunkt, aber eine Abfrage für eine dicht besiedelte Stadt benötigt möglicherweise 15 oder mehr Durchläufe, bevor das Fenster 'You've reached the end of the list'. Beobachten Sie den gerenderten HTML-Code und hören Sie auf, wenn keine neuen Einträge mehr erscheinen.

Sobald das Panel genügend Einträge geladen hat, übergeben Sie den Seitenquellcode an BeautifulSoup und extrahieren Sie die Felder. Die unten aufgeführten Klassen-Hooks waren zum Zeitpunkt der Erstellung dieses Artikels gültig, aber Maps wechselt sie nach eigenem Zeitplan, führen Sie daher vor einem Produktionslauf immer eine neue DOM-Prüfung durch.

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)

Zwei Vorgehensweisen zur Fehlertoleranz sind hier wichtig. Erstens: Verwenden Sie das aria-label Attribut dem sichtbaren Text vor, da die Bezeichnung bei Änderungen an der Benutzeroberfläche stabiler ist. Zweitens: Verwenden Sie index-sichere Lookups, damit eine fehlende Bewertung die Schleife nicht zum Absturz bringt. Wenn Sie eine tiefergehende Einführung in BeautifulSoup wünschen, ist eine interne Anleitung zu Parsing-Mustern eine nützliche Lektüre für fortgeschrittenere Selektor-Strategien.

Der letzte Schritt in Methode 1 besteht darin, Ihre geparsten Einträge auf die Festplatte zu schreiben. CSV eignet sich gut für einmalige Aufgaben, und der Wechsel zu Parquet oder einer Datenbank ist später mit einer einzigen Zeile zu bewerkstelligen.

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

Setzen Sie fehlende Felder standardmäßig immer auf einen Sentinel wie N/A anstelle einer leeren Zelle. Leere Zellen sind in nachgelagerten Pipelines mehrdeutig (fehlte das Feld oder war der Scrape fehlerhaft?) und erschweren die Überprüfung der Datenqualität. Der Aufruf von driver.quit() am Ende gibt den Chrome-Prozess und alle von ihm gehaltenen Proxy-Verbindungen frei.

Methode 1 eignet sich gut für Prototypen, ist aber ressourcenintensiv. Die sauberere Lösung für das Skalieren des Scrapings von Google Maps-Bewertungen besteht darin, das Rendering und die Proxy-Rotation an eine Scraping-API zu delegieren und einen JSON-Befehlssatz zu senden, der einem gehosteten Headless-Browser mitteilt, was auf der Seite zu tun ist. Sie erhalten denselben endgültigen HTML-Code, ohne den Overhead eines lokalen Browsers, und der Anbieter übernimmt die Wiederholungsversuche und die Proxy-Rotation, die Sie sonst selbst übernehmen müssten.

Die meisten Anbieter, einschließlich unserer WebScrapingAPI SERP API, akzeptieren einen JSON-Befehlssatz in den Request-Headern, der Scrollvorgänge, Klicks und Wartezeiten beschreibt. Das folgende Beispiel blendet das Cookie-Banner aus, scrollt das Ergebnisfenster einige Male und gibt den endgültigen HTML-Code in einer einzigen Anfrage zurück. Überprüfen Sie die genauen Headernamen und das Befehlsschema anhand der aktuellen Dokumentation des Anbieters, da diese Details variieren können.

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.")

Drei Dinge machen dieses Muster lohnenswert. Erstens müssen Sie Chrome nicht mehr auf jedem Worker ausführen und aktualisieren. Zweitens rotiert der Anbieter Proxys und wiederholt fehlgeschlagene Anfragen für Sie, was den Großteil der operativen Mühen an „schlechten Tagen“ beseitigt. Drittens kann die gesamte Pipeline in einem Cron-Job oder einer serverlosen Funktion ohne Browserabhängigkeit laufen.

Das Scraping auf Listing-Ebene zeigt Ihnen, welche Orte wichtig sind, aber der geschäftliche Wert liegt eine Ebene tiefer, im eigentlichen Bewertungstext. Die kürzeste Antwort auf die Frage, wie man Google Maps für Bewertungen auf Einzelbewertungsebene scrapt, lautet: Überspringen Sie das Parsen komplett und nutzen Sie eine strukturierte Maps Reviews API. Sie suchen einmal nach dem data_id einmal nach und rufen dann den Bewertungs-Endpunkt mit den benötigten Parametern auf.

Die Struktur ist intuitiv. engine wählt die Maps Reviews-Engine aus. data_id identifiziert den Ort. sort_by steuert die Sortierung: qualityScore (Standard, relevanteste), newestFirst, ratingHighoder ratingLow. topic_id filtert nach einem bestimmten Thema, zum Beispiel einer Themen-ID für „Amenities“, die aus der strukturierten Antwort entnommen wurde (im Brief wurde eine Beispiel-ID von /m/0f3yyn zur Überprüfung). Optionale Felder wie Snippet, Responseund Response.iso_date werden bei Null indiziert, wobei die erste Bewertung bei Index 0 steht.

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"),
    })

Fehlen Felder, werden diese standardmäßig immer ausgelassen. Rezensenten hinterlassen oft eine Sternebewertung ohne Text, und die meisten Eigentümer antworten nie, sodass das JSON Lücken aufweist.

Sowohl bei der API als auch bei den DIY-Methoden ist der erste Datensatz auf eine kleine Anzahl begrenzt. Laut der Dokumentation der Anbieter gibt eine typische Maps Reviews API etwa 10 Bewertungen pro Anfrage zurück und stellt einen next_page_token (oder einen entsprechenden Cursor) in der Antwort. Die Paginierungsschleife hat dieselbe Form, die Sie für jede tokenbasierte API verwenden würden: Rufen Sie die API so lange auf, bis das Token-Feld fehlt.

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

Auf der Selenium-Seite erfolgt die Paginierung einfach durch fortgesetztes Scrollen innerhalb der Registerkarte „Bewertungen“ der Ortskarte. Achten Sie auf die Markierung „Sie haben das Ende der Liste erreicht“ und stoppen Sie, wenn die Anzahl der angezeigten Bewertungen bei zwei aufeinanderfolgenden Scrollvorgängen nicht mehr zunimmt.

Sobald du verstanden hast, wie man Google Maps mechanisch nach Bewertungen durchsucht, besteht die langfristige Herausforderung darin, nicht gesperrt zu werden. Volumen und Unauffälligkeit sind ein Kompromiss, keine feste Einstellung. Der wichtigste Hebel ist dein Proxy-Pool. IP-Adressen von Rechenzentren werden bei Maps-Abfragen viel schneller markiert als private IPs. Sobald du also mehr als ein paar Dutzend Anfragen pro Stunde durchführst, solltest du private IPs mit länderbezogener Ausrichtung rotieren lassen. Füge zufällige Wartezeiten zwischen den Aktionen ein (300 bis 1500 ms sind ein angemessener Bereich), reduziere die Anzahl der Versuche bei 429-Fehlern exponentiell und begrenze die Anzahl der Wiederholungsversuche immer, damit ein schlechtes Ziel nicht dein gesamtes Budget aufbraucht.

Selektor-Drift ist der zweite Fehlermodus. Behandeln Sie Hooks wie hfpxzc, MW4etdund Nv2PK als volatil. Bauen Sie einen einfachen DOM-Überwachungsschritt ein, der deutlich meldet, wenn ein Selektor nichts mehr findet, bevorzugen Sie aria-label und strukturelle Selektoren gegenüber Klassennamen, wo immer möglich, und behalte mindestens einen Fallback pro kritischem Feld bei. Ein kurzer Leitfaden zu häufigen Blockierungssignalen und wie man sie umgeht, ist es wert, mit einem Lesezeichen versehen zu werden, und der ausführlichere Leitfaden unseres Teams zur Vermeidung von IP-Sperren geht tiefer auf Header-Rotation und Fingerprinting ein (eine nützliche Lektüre, wenn ein einst stabiles Skript plötzlich 403-Fehler zurückgibt).

Der Sinn des Ganzen sind entscheidungsreife Daten, nicht eine riesige CSV-Datei. Eine kurze Nachbearbeitungs-Pipeline verwandelt rohe Bewertungen in etwas, worauf ein Produkt- oder Marketingteam reagieren kann.

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)

Vier Schritte erledigen den Großteil der Arbeit: Duplikatbereinigung durch review_id, Beschneiden der Bewertungen auf einen Bereich von 0 bis 5, Entfernen von Leerzeichen und Emoji-Rauschen aus dem Text sowie Markieren der Stimmungs-Polarität pro Zeile mit einer schlanken NLP-Bibliothek. Von dort aus ist es ein direkter Schritt von Pandas zu SQL oder von Pandas zum Data Warehouse. Diese Ausgabe ist die Grundlage für ein Dashboard zur Überwachung von Bewertungen oder einen Stimmungs-Benchmark für Wettbewerber, womit sich der Kreis zu den Anwendungsfällen schließt, mit denen wir begonnen haben.

• Die offizielle Google Places API eignet sich gut, um einige Bewertungen in ein Produkt einzubetten, aber aufgrund der Beschränkungen pro Standort ist sie das falsche Werkzeug für Analysen oder Wettbewerbsrecherchen.
• Eine Kombination aus Selenium und Residential-Proxys bietet Ihnen die größte Kontrolle. Planen Sie Cookie-Banner, scrollgesteuertes Laden und rotierende CSS-Class-Hooks wie hfpxzc und Nv2PK.
• Eine Scraping-API mit einem JSON-Render-Befehlssatz macht den lokalen Browser komplett überflüssig und ist der sauberste Weg für geplante, wiederholbare Aufgaben.
• Eine strukturierte Maps Reviews API ist der schnellste Weg zu sauberen Feldern pro Bewertung. Verwenden Sie sort_by, topic_idund next_page_token , um Tiefe und Aufteilung zu steuern.
• Behandeln Sie die Pipeline als Pipeline. Führen Sie eine Deduplizierung durch review_id, normalisieren Sie Bewertungen, entfernen Sie Störsignale und kennzeichnen Sie die Stimmung, damit die Ausgabe entscheidungsbereit ist und nicht nur gespeichert wird.

Öffentliche Bewertungsdaten gelten in vielen Rechtsordnungen allgemein als scrapbar, wenn sie für Analysen oder Forschungszwecke verwendet werden, aber die Nutzungsbedingungen von Google beschränken den automatisierten Zugriff auf seine Produkte, und die US-Rechtsprechung zum Scraping öffentlicher Daten entwickelt sich weiter. Prüfen Sie stets die Nutzungsbedingungen von Maps, beachten Sie robots.txt, vermeiden Sie das Scraping von personenbezogenen Daten, die über das öffentlich sichtbare Maß hinausgehen, und konsultieren Sie einen Rechtsbeistand vor der kommerziellen Nutzung.

Die Places-API unterliegt einer Ratenbegrenzung, erfordert ein kostenpflichtiges Google Cloud-Projekt und liefert nur einen kleinen Ausschnitt der in der Maps-Benutzeroberfläche angezeigten Bewertungen. Das reicht zwar aus, um ein paar Bewertungen in ein Produkt einzubetten, ist aber für Stimmungsanalysen, Wettbewerbsvergleiche oder andere Anwendungsfälle, die eine repräsentative Stichprobe erfordern, unbrauchbar.

Nicht zuverlässig mit Raw requests, da Maps eine JavaScript-lastige SPA ist. Die realistischen Alternativen sind eine Scraping-API, die einen gehosteten Headless-Browser für Sie ausführt, oder eine strukturierte Reviews-API, die geparstes JSON zurückgibt, ohne etwas auf der Client-Seite zu rendern.

Häufig genug, dass Sie nicht davon ausgehen sollten, dass ein Klassen-Hook dauerhaft ist. Schützen Sie sich vor Abweichungen mit aria-label Selektoren, strukturellen XPath-Fallbacks, einem kleinen DOM-Überwachungsjob, der lautstark fehlschlägt, wenn ein Selektor keine Treffer liefert, und einer Warnmeldung, die dich vor dem nächsten geplanten Lauf benachrichtigt.

Eine typische Maps Reviews API gibt etwa 10 Bewertungen pro Anfrage und einen next_page_token Cursor für den nächsten Stapel. Es gibt keine feste Obergrenze, aber extrem alte Bewertungen lassen sich immer schwerer abrufen. Durchlaufe die Tokens, bis keine mehr zurückgegeben werden, und scrolle auf der Selenium-Seite so lange durch den Bewertungs-Tab, bis die Anzahl nicht mehr steigt.

Es gibt keine einzige richtige Antwort darauf, wie man Google Maps nach Bewertungen durchsucht. Die richtige Antwort hängt davon ab, wie viele Daten Sie benötigen, wie oft Sie diese benötigen und wie viel betrieblichen Aufwand Sie verkraften können. Für eine einmalige Überprüfung der Standorte eines Mitbewerbers reichen Selenium und ein Residential-Proxy völlig aus. Für eine wiederkehrende Sentiment-Pipeline, die weiterlaufen muss, während Google Klassennamen ändert und seinen Anti-Bot-Stack verschärft, ist eine verwaltete Scraping-API oder eine strukturierte Maps Reviews API der Weg, der Ihnen keine schlaflosen Nächte bereitet.

Egal, für welche Methode Sie sich entscheiden: Behandeln Sie die Ausgabe wie Daten und nicht wie HTML. Führen Sie eine Deduplizierung nach Bewertungs-ID durch, normalisieren Sie Bewertungen, entfernen Sie Rauschen, bewerten Sie die Stimmung und laden Sie die Daten an einen abfragbaren Ort, damit sich die Arbeit in einem Dashboard oder Modell auszahlt und nicht in einer veralteten CSV-Datei.

Wenn Sie lieber keine Chrome-Flotte betreiben und warten möchten, nur um mit den Änderungen an der Maps-Benutzeroberfläche Schritt zu halten, übernimmt unsere Scraper-SERP-API bei WebScrapingAPI die Proxy-Rotation, das Headless Rendering und das Lösen von CAPTCHAs hinter einem einzigen Endpunkt, sodass Sie den Python-Code aus diesem Leitfaden beibehalten und lediglich die Abrufebene austauschen können. Erstellen Sie einen API-Schlüssel, verweisen Sie ihn auf eine Maps-URL und beginnen Sie noch am selben Nachmittag mit der Erfassung sauberer Bewertungsdaten.