Google Maps Bewertungen mit Python scrapen (2026) — Vollständige Anleitung

Wenn du schon mal versucht hast, Bewertungen von Google Maps manuell rauszukopieren, kennst du den Schmerz. Unternehmen anklicken, durch die Bewertungen scrollen, jede einzelne kopieren... mach das bei 50 Unternehmen und dein ganzer Nachmittag ist futsch. Kenn ich.

Genau deshalb macht es so viel Sinn, Google Maps Bewertungen mit Python zu scrapen. Du schreibst den Code einmal, und er erledigt die ganze nervige Arbeit für dich — Reviewer-Namen, Sternebewertungen, den kompletten Bewertungstext, Daten, alles. Egal ob du die Reputation deiner eigenen Marke im Blick behältst, die Konkurrenz beobachtest oder einen Datensatz für ein Forschungsprojekt aufbaust — Automatisierung ist der richtige Weg.

In dieser Anleitung zeige ich dir zwei verschiedene Methoden: eine mit Playwright und eine mit Selenium. Beide funktionieren. Außerdem zeige ich dir, wie du Googles Anti-Bot-Systeme umgehst (denn ja, die werden versuchen dich zu blockieren), und wenn du den ganzen Code lieber überspringen willst, stelle ich dir ein No-Code-Tool vor, das alles für dich übernimmt.

Du musst kein Python-Experte sein, um mitzumachen. Wenn du eine Library installieren und ein Script ausführen kannst, reicht das.

Was sind Google Maps Bewertungen und warum sollte man sie scrapen?

Du weißt natürlich, was Google Maps Bewertungen sind — diese Sternebewertungen und Kommentare, die Leute bei Unternehmen hinterlassen. Jede Pizzeria, Zahnarztpraxis, jedes Hotel und jeder Handwerker auf Google Maps hat welche. Was dir vielleicht nicht klar ist: wie viele nützliche Daten in diesen Bewertungen stecken.

Welche Daten kannst du extrahieren?

Folgendes kannst du aus jeder Bewertung ziehen:

• Reviewer-Name — wer die Bewertung geschrieben hat
• Sternebewertung — der Score von 1 bis 5 Sternen
• Bewertungstext — der eigentliche Kommentar
• Bewertungsdatum — wann die Bewertung gepostet wurde
• Antwort des Inhabers — falls das Unternehmen geantwortet hat, bekommst du das auch
• Reviewer-Profil-Link — die Google-Profil-URL
• Bewertungsfotos — alle angehängten Bilder

Und was machen Leute tatsächlich mit diesen Daten?

Ziemlich viel, ehrlich gesagt:

• Markenbeobachtung — im Blick behalten, was Leute über dein Unternehmen an verschiedenen Standorten sagen
• Wettbewerbsanalyse — herausfinden, wo Konkurrenten schwächeln (oder gut abschneiden) basierend auf deren Bewertungen
• Sentiment-Analyse — Bewertungen durch NLP-Tools laufen lassen, um Muster in der Kundenstimmung zu erkennen
• Leadgenerierung — Unternehmen mit schlechten Bewertungen finden, die dein Produkt oder deine Dienstleistung brauchen könnten
• Marktforschung — Bewertungstrends über eine ganze Branche hinweg analysieren
• Akademische Arbeit — Forschungsdatensätze rund um Konsumentenverhalten aufbauen

Googles offizielle API vs. Web Scraping — Was ist der Unterschied?

Bevor wir in den Code einsteigen, solltest du etwas wissen. Google hat eine offizielle API dafür — die Places API — aber ehrlich gesagt ist die für das, was die meisten Leute brauchen, ziemlich eingeschränkt.

Google Places API (Der offizielle Weg)

So sieht's mit der API aus:

• Sie liefert dir nur 5 Bewertungen pro Unternehmen. Fünf. Das ist das Maximum.
• Sie kostet Geld — etwa 17 $ pro 1.000 Anfragen für Place Details
• Du bekommst überhaupt keinen Zugriff auf die vollständige Bewertungshistorie
• Google entscheidet, welche 5 Bewertungen dir angezeigt werden (deren Algorithmus wählt aus, nicht du)
• Positiv ist: die Daten kommen als sauberes JSON zurück, also ist das Parsen einfach

Web Scraping (Das machen wir hier)

Scraping dagegen:

• Holt dir jede einzelne Bewertung, die ein Unternehmen hat — nicht nur 5
• Es ist kostenlos (naja, deine Zeit ist nicht kostenlos, aber die Tools schon)
• Du bekommst die komplette Bewertungshistorie mit echten Daten
• Es ist mehr Aufwand einzurichten, keine Frage
• Und du musst deinen Code ab und zu aktualisieren, wenn Google ihr Seitenlayout ändert

Wenn dir also 5 Bewertungen reichen, nimm die API. Aber wenn du das vollständige Bild brauchst — Hunderte oder Tausende von Bewertungen — musst du scrapen, oder ein Tool wie Livescraper nutzen, das es für dich erledigt.

Voraussetzungen — Was du vorher brauchst

Lass uns deinen Rechner einrichten. Nichts davon ist kompliziert, aber du brauchst ein paar Dinge vorab installiert.

1. Python 3.9 oder höher

Öffne dein Terminal (oder die Eingabeaufforderung unter Windows) und prüfe deine Version:

python --version
# Du brauchst Python 3.9 oder neuer. 3.12 oder 3.13 ist ideal in 2026.

Noch kein Python installiert? Hol es dir von python.org. Auf dem Mac geht auch brew install python.

2. Virtuelle Umgebung erstellen

Das hält deine Projekt-Abhängigkeiten getrennt von allem anderen auf deinem System. Glaub mir, das erspart dir später Kopfschmerzen:

# Projektordner erstellen und reinwechseln
mkdir google-reviews-scraper
cd google-reviews-scraper

# Virtuelle Umgebung erstellen
python -m venv venv

# Aktivieren
# Mac/Linux:
source venv/bin/activate
# Windows:
venv\\Scripts\\activate

3. Libraries installieren

Wir behandeln unten zwei Methoden. Installier die, die du verwenden willst (oder beide, wenn du beides ausprobieren möchtest):

# Für Playwright (das würde ich empfehlen)
pip install playwright pandas
playwright install chromium

# Für Selenium
pip install selenium webdriver-manager pandas beautifulsoup4

Mach dir noch keine Gedanken darüber, was jede Library macht — ich erkläre alles nach und nach.

Methode 1: Bewertungen mit Playwright scrapen (Empfohlen)

Playwright ist ein Browser-Automatisierungstool von Microsoft. Ich bevorzuge es gegenüber Selenium für diese Art von Arbeit, weil es dynamische Seiten besser handhabt, schneller ist und du weniger Boilerplate-Code schreiben musst. Es kam ein paar Jahre nach Selenium raus und das merkt man — viele Ecken und Kanten sind geglättet.

Warum Playwright statt Selenium?

Hier die Kurzfassung:

• Es wartet automatisch für dich. Playwright weiß, wann ein Element bereit ist, bevor es draufklickt. Bei Selenium streust du ständig time.sleep() überall rein und hoffst auf das Beste.
• Es ist wirklich schneller. Die Art, wie es unter der Haube mit dem Browser kommuniziert, ist effizienter.
• Selektoren sind flexibler. CSS, XPath, Textabgleich, ARIA-Rollen — alles eingebaut.
• Einfacher unauffällig zu machen. Es ist simpler zu konfigurieren, damit Websites dich nicht sofort als Bot erkennen.
• Funktioniert mit mehreren Browsern. Chromium, Firefox und WebKit (Safaris Engine) werden alle unterstützt.

Schritt 1: Das Grundgerüst

Gut, lass uns Code schreiben. Erstelle eine Datei namens scraper.py und fang mit dem Browser-Setup an:

from playwright.sync_api import sync_playwright
import pandas as pd
import time
import random
import re

def create_browser():
    """Launch a browser that looks like a real user."""
    p = sync_playwright().start()
    browser = p.chromium.launch(
        headless=False,  # Set True for production
        args=[
            '--disable-blink-features=AutomationControlled',
            '--no-sandbox',
        ]
    )
    context = browser.new_context(
        viewport={'width': 1366, 'height': 768},
        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',
        locale='en-US',
    )
    return p, browser, context

Lass mich erklären, was hier passiert. Wir starten einen Chromium-Browser mit Einstellungen, die ihn wie eine normale Person beim Surfen aussehen lassen — nicht wie ein Script. Der headless=False-Teil bedeutet, dass das Browserfenster tatsächlich auf deinem Bildschirm erscheint, was fürs Debuggen super ist, weil du genau sehen kannst, was passiert. Der User-Agent-String sagt Google, welchen Browser wir angeblich verwenden, und das disable-blink-features-Flag entfernt das verräterische Zeichen, das sagt „Hey, dieser Browser wird von Automatisierungssoftware gesteuert."

Schritt 2: Zum Unternehmen navigieren und den Bewertungs-Tab öffnen

Jetzt müssen wir tatsächlich eine Google Maps Unternehmensseite aufrufen und auf den Bewertungsbereich klicken. Dieser Teil ist unkompliziert:

def open_reviews_panel(page, place_url):
    """Navigate to a Google Maps place and open the reviews tab."""
    page.goto(place_url, wait_until='networkidle')

    # Accept cookies if prompted
    try:
        page.click('button:has-text("Accept all")', timeout=3000)
    except:
        pass

    # Wait for the page to fully load
    page.wait_for_selector('button[data-tab-index="1"]', timeout=10000)

    # Click on the "Reviews" tab
    page.click('button[data-tab-index="1"]')
    time.sleep(2)  # Let reviews load

    print("Reviews panel opened successfully")

Ziemlich einfach, oder? Wir rufen die URL auf, warten bis sie vollständig geladen ist, behandeln das nervige Cookie-Consent-Popup (falls du in Europa bist, weißt du genau, wovon ich rede) und klicken dann auf den „Bewertungen"-Tab. Der data-tab-index="1"-Selektor zeigt auf den Bewertungs-Tab — zumindest Stand Anfang 2026. Wenn Google ihr Layout ändert, muss dieser Selektor eventuell aktualisiert werden.

Schritt 3: Nach unten scrollen, um mehr Bewertungen zu laden

Hier wird es interessant. Google Maps lädt nicht alle Bewertungen auf einmal — es zeigt dir vielleicht 10 und lädt dann mehr nach, wenn du runterscrollst. Also müssen wir immer wieder scrollen und warten, scrollen und warten, bis wir alles haben (oder unsere Zielanzahl erreicht ist):

def scroll_reviews(page, max_reviews=100):
    """Scroll the reviews panel to load more reviews."""
    scrollable = page.query_selector('div.m6QErb.DxyBCb.kA9KIf.dS8AEf')
    if not scrollable:
        print("Could not find scrollable reviews container")
        return

    last_count = 0
    scroll_attempts = 0
    max_attempts = 50

    while scroll_attempts < max_attempts:
        # Scroll down inside the reviews panel
        scrollable.evaluate('el => el.scrollTop = el.scrollHeight')

        # Wait for new reviews to load
        time.sleep(random.uniform(1.5, 3.0))

        # Count current reviews
        reviews = page.query_selector_all('div.jftiEf.fontBodyMedium')
        current_count = len(reviews)

        print(f"Loaded {current_count} reviews...")

        # Stop if we've reached our target
        if current_count >= max_reviews:
            print(f"Reached target of {max_reviews} reviews")
            break

        # Stop if no new reviews loaded (we've reached the end)
        if current_count == last_count:
            scroll_attempts += 1
            if scroll_attempts >= 3:
                print(f"No more reviews to load. Total: {current_count}")
                break
        else:
            scroll_attempts = 0

        last_count = current_count

Der knifflige Teil hier ist, den richtigen scrollbaren Container zu finden — es ist nicht die Hauptseite, die scrollt, sondern ein bestimmtes div innerhalb des Bewertungs-Panels. Wir scrollen es mit JavaScript nach unten und pausieren dann für eine zufällige Zeitspanne (zwischen 1,5 und 3 Sekunden), um menschlicher zu wirken. Das Script läuft weiter, bis wir entweder unsere Zielanzahl an Bewertungen erreicht haben oder nach ein paar Versuchen keine neuen mehr auftauchen.

Schritt 4: Die Bewertungsdaten extrahieren

Jetzt wo alle Bewertungen auf der Seite geladen sind, müssen wir die Daten aus jeder einzelnen rausholen. Diese Funktion geht durch jedes Bewertungselement und zieht Name, Bewertung, Text, Datum und eventuelle Inhaberantworten heraus:

def extract_reviews(page):
    """Extract all review data from the loaded reviews."""
    reviews_data = []
    review_elements = page.query_selector_all('div.jftiEf.fontBodyMedium')

    for element in review_elements:
        try:
            # Reviewer name
            name_el = element.query_selector('.d4r55')
            name = name_el.inner_text() if name_el else 'Anonymous'

            # Star rating
            rating_el = element.query_selector('.kvMYJc')
            rating = 0
            if rating_el:
                aria = rating_el.get_attribute('aria-label')
                match = re.search(r'(\\d+)', aria or '')
                rating = int(match.group(1)) if match else 0

            # Review text (click "More" to expand if needed)
            more_btn = element.query_selector('button.w8nwRe.kyuRq')
            if more_btn:
                try:
                    more_btn.click()
                    time.sleep(0.3)
                except:
                    pass

            text_el = element.query_selector('.wiI7pd')
            text = text_el.inner_text() if text_el else ''

            # Review date
            date_el = element.query_selector('.rsqaWe')
            date = date_el.inner_text() if date_el else ''

            # Owner response
            response_el = element.query_selector('.CDe7pd')
            owner_response = response_el.inner_text() if response_el else ''

            reviews_data.append({
                'reviewer_name': name,
                'rating': rating,
                'review_text': text,
                'review_date': date,
                'owner_response': owner_response,
            })

        except Exception as e:
            print(f"Error extracting review: {e}")
            continue

    return reviews_data

Eine Sache noch: Manche Bewertungen haben einen „Mehr"-Button, der den vollständigen Text verbirgt. Wir versuchen, auf diesen Button zu klicken, um die Bewertung aufzuklappen, bevor wir den Text auslesen. Das funktioniert nicht immer perfekt, aber es erwischt die meisten.

Schritt 5: Alles zusammensetzen

So, jetzt verbinden wir all diese Funktionen zu einem Script, das du tatsächlich ausführen kannst:

def scrape_google_reviews(place_url, max_reviews=100):
    """Main function to scrape Google Maps reviews."""
    p, browser, context = create_browser()
    page = context.new_page()

    try:
        # Step 1: Open the reviews panel
        open_reviews_panel(page, place_url)

        # Step 2: Scroll to load reviews
        scroll_reviews(page, max_reviews)

        # Step 3: Extract review data
        reviews = extract_reviews(page)

        # Step 4: Save to CSV
        df = pd.DataFrame(reviews)
        filename = 'google_reviews.csv'
        df.to_csv(filename, index=False, encoding='utf-8')
        print(f"\\nSaved {len(reviews)} reviews to {filename}")
        print(f"Average rating: {df['rating'].mean():.1f} stars")

        return reviews

    finally:
        browser.close()
        p.stop()


# Run the scraper
if __name__ == '__main__':
    url = 'https://www.google.com/maps/place/YOUR_BUSINESS_URL'
    reviews = scrape_google_reviews(url, max_reviews=200)
    print(f"\\nDone! Scraped {len(reviews)} reviews")

Ersetze einfach YOUR_BUSINESS_URL durch einen echten Google Maps Link. Geh auf Google Maps, such nach einem beliebigen Unternehmen und kopiere die URL aus der Adressleiste deines Browsers. Das kommt da rein.

Methode 2: Bewertungen mit Selenium scrapen

Vielleicht hast du Selenium schon mal benutzt und bist damit vertraut. Oder vielleicht unterstützt deine Arbeitsumgebung Playwright aus irgendeinem Grund nicht. Kein Problem — Selenium kann den Job definitiv auch erledigen. Der Code ist etwas ausführlicher, aber die Logik ist dieselbe.

Selenium-Setup

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

def create_selenium_driver():
    """Create a Selenium Chrome driver with stealth settings."""
    options = webdriver.ChromeOptions()
    options.add_argument('--disable-blink-features=AutomationControlled')
    options.add_argument('--window-size=1366,768')
    options.add_argument('--lang=en-US')
    options.add_experimental_option('excludeSwitches', ['enable-automation'])
    options.add_experimental_option('useAutomationExtension', False)

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

    # Remove the webdriver flag
    driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
        'source': '''
            Object.defineProperty(navigator, 'webdriver', {get: () => undefined})
        '''
    })

    return driver

Selenium Review Scraper

def scrape_with_selenium(place_url, max_reviews=100):
    """Scrape Google Maps reviews using Selenium."""
    driver = create_selenium_driver()

    try:
        driver.get(place_url)
        time.sleep(3)

        # Accept cookies
        try:
            cookie_btn = WebDriverWait(driver, 5).until(
                EC.element_to_be_clickable((By.XPATH,
                    '//button[contains(text(), "Accept all")]'))
            )
            cookie_btn.click()
        except:
            pass

        # Click Reviews tab
        reviews_tab = WebDriverWait(driver, 10).until(
            EC.element_to_be_clickable((By.CSS_SELECTOR,
                'button[data-tab-index="1"]'))
        )
        reviews_tab.click()
        time.sleep(2)

        # Scroll to load reviews
        scrollable = driver.find_element(By.CSS_SELECTOR,
            'div.m6QErb.DxyBCb.kA9KIf.dS8AEf')

        last_count = 0
        for _ in range(50):
            driver.execute_script(
                'arguments[0].scrollTop = arguments[0].scrollHeight',
                scrollable
            )
            time.sleep(random.uniform(1.5, 3.0))

            reviews = driver.find_elements(By.CSS_SELECTOR,
                'div.jftiEf.fontBodyMedium')
            if len(reviews) >= max_reviews or len(reviews) == last_count:
                break
            last_count = len(reviews)

        # Parse with BeautifulSoup for easier extraction
        soup = BeautifulSoup(driver.page_source, 'html.parser')
        review_elements = soup.select('div.jftiEf.fontBodyMedium')

        reviews_data = []
        for el in review_elements:
            name = el.select_one('.d4r55')
            rating = el.select_one('.kvMYJc')
            text = el.select_one('.wiI7pd')
            date = el.select_one('.rsqaWe')

            rating_val = 0
            if rating and rating.get('aria-label'):
                import re
                m = re.search(r'(\\d+)', rating['aria-label'])
                rating_val = int(m.group(1)) if m else 0

            reviews_data.append({
                'reviewer_name': name.text if name else 'Anonymous',
                'rating': rating_val,
                'review_text': text.text if text else '',
                'review_date': date.text if date else '',
            })

        # Save to CSV
        df = pd.DataFrame(reviews_data)
        df.to_csv('reviews_selenium.csv', index=False)
        print(f"Saved {len(reviews_data)} reviews")
        return reviews_data

    finally:
        driver.quit()

Playwright vs. Selenium — Welches solltest du wählen?

Das werde ich oft gefragt. Hier ein direkter Vergleich:

Merkmal	Playwright	Selenium
Geschwindigkeit	Schneller (Async-Unterstützung)	Langsamer
Auto-Waiting	Eingebaut	Manuell (WebDriverWait)
Einrichtung	Sehr einfach	Driver-Management nötig
Anti-Erkennung	Bessere Stealth-Optionen	Braucht undetected-chromedriver
Community	Wächst schnell	Größte Community
Lernkurve	Mittel	Sanft

Meine ehrliche Meinung? Wenn du bei Null anfängst, nimm Playwright. Du schreibst weniger Code und hast weniger Kopfschmerzen. Aber wenn du schon Selenium-Code irgendwo laufen hast, gibt es keinen zwingenden Grund, alles umzuschreiben.

Wie du vermeidest, von Google blockiert zu werden

Das ist der Teil, den die meisten Tutorials überspringen, aber er ist vermutlich der wichtigste. Google ist richtig gut darin, Bots zu erkennen. Wenn du einfach einen Headless-Browser startest und ihre Server bombardierst, wirst du innerhalb von Minuten gesperrt. So bleibst du unter dem Radar.

1. Zufällige Pausen zwischen Aktionen einbauen

Niemand klickt einen Button und dann sofort einen anderen 50 Millisekunden später. Echte Menschen zögern, lesen Sachen, werden abgelenkt. Dein Scraper sollte das auch tun:

import random

def human_delay(min_sec=1.0, max_sec=3.0):
    """Wait a random amount of time to mimic human behavior."""
    delay = random.uniform(min_sec, max_sec)
    time.sleep(delay)

2. Den User Agent wechseln

Wenn jede einzelne Anfrage vom exakt gleichen Browser-Fingerprint kommt, ist das ein eindeutiges Zeichen. Misch es auf:

USER_AGENTS = [
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/124.0.0.0',
    'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_4) AppleWebKit/537.36 Chrome/124.0.0.0',
    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/124.0.0.0',
    'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Firefox/125.0',
]

user_agent = random.choice(USER_AGENTS)

3. Proxies verwenden (besonders bei größeren Jobs)

Sobald du mehr als eine Handvoll Unternehmen scrapst, solltest du deine IP-Adresse rotieren. Sonst sieht Google Hunderte von Anfragen von einem Ort und sperrt dich:

def create_browser_with_proxy(proxy_url):
    """Launch browser through a proxy server."""
    p = sync_playwright().start()
    browser = p.chromium.launch(
        proxy={'server': proxy_url},
        headless=True,
    )
    return p, browser

4. Sei nicht gierig mit der Geschwindigkeit

Ich weiß, es ist verlockend, so schnell wie möglich zu scrapen, aber Geduld zahlt sich hier aus. Ein paar Richtwerte, die bei mir funktioniert haben:

• Halte dich an etwa 10-20 Unternehmen pro Stunde von einer IP-Adresse
• Warte 3-5 Sekunden zwischen dem Laden verschiedener Unternehmensseiten
• Pause 1-3 Sekunden zwischen Scroll-Aktionen im Bewertungs-Panel
• Alle 10-15 Unternehmen eine längere Pause einlegen — so 30-60 Sekunden. Hol dir einen Kaffee oder so.

Häufige Probleme (und wie du sie löst)

Du wirst auf Probleme stoßen. Das passiert jedem. Hier sind die, die mir am häufigsten begegnen:

„Die Bewertungen laden überhaupt nicht"

Das bedeutet meistens, dass Google gemerkt hat, dass du ein Bot bist, oder sie haben etwas am Seitenlayout geändert. Erster Versuch: Setze headless=False, damit du das Browserfenster tatsächlich sehen kannst. Gibt es ein CAPTCHA? Ein Cookie-Banner, das alles blockiert? Manchmal ist die Lösung so simpel wie auf „Akzeptieren" bei einem Popup zu klicken, das du nicht bedacht hast. Andere Male hat Google ihre CSS-Klassen geändert und du musst deine Selektoren aktualisieren.

„Ich bekomme nur 10 Bewertungen, obwohl es Hunderte gibt"

Das Scrollen funktioniert nicht richtig. Überprüfe, ob du im richtigen Container scrollst — es ist ein bestimmtes div innerhalb des Bewertungs-Panels, nicht die Hauptseite. Füge ein print(scrollable) hinzu, um sicherzustellen, dass es nicht None ist. Versuche auch, die Pause zwischen den Scrolls zu erhöhen — manchmal sind Googles Server langsam beim Senden der nächsten Bewertungs-Charge.

„Es funktioniert für 3-4 Unternehmen und dann werde ich gesperrt"

Du bist zu schnell. Verlangsame, füge längere Pausen zwischen den Unternehmen ein und ziehe ernsthaft in Betracht, Proxies zu verwenden, falls du das noch nicht tust. Zehn bis zwanzig Unternehmen pro Session von einer IP sind ein realistisches Ziel.

„Die Selektoren finden nichts"

Google ändert ihre CSS-Klassennamen öfter als man denkt. Wenn das passiert, öffne Google Maps in deinem eigenen Browser, mach einen Rechtsklick auf eine Bewertung, klick auf „Element untersuchen" und schau dir die aktuellen Klassennamen an. Dann aktualisiere deinen Code entsprechend. Ist nervig, aber das gehört zum Web Scraping dazu.

Oder überspring einfach den Code — Nutze stattdessen Livescraper

Hör mal, ich hab gerade einen guten Teil dieses Artikels damit verbracht, dir beizubringen, wie du einen Scraper von Grund auf baust. Und alles oben funktioniert. Aber ich würde lügen, wenn ich sagen würde, es wäre wartungsfrei. Google ändert ihr Seitenlayout, deine Selektoren brechen. Sie rollen neue Anti-Bot-Maßnahmen aus, deine Proxies funktionieren nicht mehr. Du fixst eine Sache und etwas anderes geht kaputt. Ein Kreislauf.

Wenn du einfach nur die Daten willst, ohne dich mit all dem rumzuschlagen, ist genau dafür Livescrapers Bewertungs-Scraper da.

Warum Livescraper statt selber bauen?

Merkmal	DIY Python Scraper	Livescraper
Einrichtungszeit	Stunden bis Tage	2 Minuten
Wartung	Ständig (Selektoren brechen)	Null — wir kümmern uns drum
Anti-Erkennung	Proxies & Delays selbst managen	Eingebaute Proxy-Rotation
Skalierung	Begrenzt durch deinen Rechner	Cloud-basiert, unbegrenzt
Ausgabeformat	CSV (manueller Export)	CSV, JSON, Excel
Coding nötig	Ja (Python)	Nein
Kosten	Kostenlos + deine Zeit	Kostenloses Kontingent verfügbar

So funktioniert's (ernsthaft, 3 Schritte)

1. Account erstellen — geh auf app.livescraper.com und melde dich an. Der Einstieg ist kostenlos.
2. Sag ihm, was er scrapen soll — füge die Google Maps URL ein oder tippe einfach den Unternehmensnamen ein. Wähle „Reviews Scraper" als Aufgabentyp.
3. Datei herunterladen — klick auf „Start Scraping" und lade die Ergebnisse als CSV oder JSON herunter, wenn's fertig ist.

Keine Python-Umgebung einrichten, keine Proxies kaufen, keine Selektoren fixen wenn sie kaputtgehen. Du bekommst einfach die Daten. Ich weiß, das klingt wie ein Werbeslogan, aber wenn du schon mal um 2 Uhr nachts einen Scraper debuggt hast, weil Google eine CSS-Klasse geändert hat... dann lernst du die Einfachheit zu schätzen.

Was kannst du noch mit Livescraper machen?

Bewertungen sind nicht das Einzige. Wenn du schon Bewertungsdaten ziehst, brauchst du wahrscheinlich auch andere Unternehmensdaten:

• Google Maps Scraper — Firmennamen, Adressen, Telefonnummern, Websites, Bewertungen aus jeder Maps-Suche holen
• E-Mail Scraper — E-Mail-Adressen von Unternehmenswebsites extrahieren (super für Outreach)
• Google Search Scraper — URLs, Titel und Snippets aus Google-Suchergebnissen extrahieren
• B2B Lead-Datenbank — eine fertige Datenbank mit Unternehmens-Leads und verifizierten Kontaktdaten, ohne Scraping nötig

Ein kurzes Wort zur Rechtslage

Ich bin kein Anwalt, also ist das keine Rechtsberatung. Aber hier ist, was allgemein über das Scrapen öffentlich zugänglicher Daten wie Google-Bewertungen gilt.

Du bist wahrscheinlich auf der sicheren Seite, wenn du...

• Öffentliche Bewertungsdaten für eigene Recherchen oder Analysen scrapst
• Die Bewertungen deines eigenen Unternehmens in großen Mengen abrufst
• Akademische Forschung mit ordnungsgemäß anonymisierten Daten betreibst
• Wettbewerbsanalysen für interne Geschäftsentscheidungen durchführst

Sei vorsichtig, wenn du...

• Bewertungen kopierst und auf deiner eigenen Website veröffentlichst
• So aggressiv scrapst, dass du im Grunde Googles Server DDoSt
• Persönliche Daten von Reviewern speicherst, ohne an die DSGVO oder andere Datenschutzgesetze zu denken
• Die Daten nutzt, um bestimmte Reviewer gezielt anzugehen oder zu belästigen (mach das offensichtlich nicht)

Generelle gute Gewohnheiten

• Wirf einen Blick auf robots.txt bevor du loslegst — dort steht, was der Seitenbetreiber bevorzugt
• Halte deine Anfragerate im Rahmen
• Behalte persönliche Daten nicht länger als du sie tatsächlich brauchst
• Beschränke dich auf legitime Geschäftszwecke
• Wenn Compliance ein Thema ist, kümmert sich ein Service wie Livescraper um vieles davon für dich

Zusammenfassung

Das war eine Menge Stoff, aber du solltest jetzt ein ziemlich solides Verständnis davon haben, wie man Google Maps Bewertungen mit Python scrapt. Wir sind den kompletten Playwright-Ansatz durchgegangen (den ich für jedes neue Projekt wählen würde), den Selenium-Ansatz (absolut in Ordnung, wenn du das kennst), Anti-Erkennungstricks und Fehlerbehebung für die häufigsten Kopfschmerzen.

Die Realität ist: Einen Scraper zu bauen ist der einfache Teil. Ihn langfristig zuverlässig am Laufen zu halten — sich mit Googles ständigen Änderungen herumzuschlagen, Proxies zu verwalten, kaputte Selektoren zu fixen — da steckt die eigentliche Zeitinvestition. Je nach deinen Anforderungen macht es also möglicherweise mehr Sinn, einfach ein Tool zu nutzen, das sich um all das im Hintergrund kümmert.

Wenn das ansprechend klingt, probier Livescraper aus. Es gibt ein kostenloses Kontingent, damit du es ohne Verpflichtung testen kannst. Und wenn du lieber den DIY-Weg gehst, hat der Code oben alles, was du zum Loslegen brauchst. Viel Erfolg bei deinem Projekt!