Kundenbewertungen scrapenEine vollständige Python-Pipeline

Kundenbewertungen gehören zu den nützlichsten öffentlichen Daten im Web. Bewertungen, schriftliches Feedback und Verifizierungskennzeichen zeigen, was Menschen wirklich über ein Produkt denken, und sie werden ständig aktualisiert. Das Problem: Die meisten Bewertungsseiten werden clientseitig gerendert und paginieren über Dutzende oder Hunderte von Seiten, sodass eine einfache HTTP-Anfrage nur eine leere Hülle zurückgibt. Dieser Leitfaden zeigt Ihnen, wie Sie Kundenbewertungen mit einer kleinen, lauffähigen Python-Pipeline scrapen: die JavaScript-intensive Seite rendern, strukturierte Felder parsen, durch den vollständigen Satz paginieren, die Ergebnisse speichern und optional Sentiment-Analyse darüber laufen lassen.

Um dies ehrlich und verteidigbar zu halten, beschränkt sich die gesamte Anleitung auf öffentliche Bewertungen: Bewertung, Titel, Body, Datum und Verifizierungsabzeichen, die jeder ohne Anmeldung sehen kann. Sie berührt keine Nutzerkonten, login-gesperrte Inhalte oder personenbezogene Daten über das hinaus, was eine Plattform bereits öffentlich anzeigt. Der Abschnitt zu Ethik und AGB am Ende ist kein Standardtext, lesen Sie ihn also, bevor Sie diesen Code in der Produktion einsetzen.

Warum Kundenbewertungen scrapen

Eine einzelne Bewertung verrät Ihnen die Meinung einer Person. Ein paar Tausend davon, strukturiert in abfragbare Zeilen, zeigen Ihnen, wo ein Produkt gewinnt und wo es still Kunden verliert. Das ist der Wert: Eine gerenderte Bewertungsseite in saubere, vergleichbare Daten umwandeln, die Sie visualisieren, über die Zeit verfolgen oder in ein Modell einspeisen können. Teams nutzen das für Wettbewerbs-Benchmarking, Produktlücken-Analyse, Brand-Monitoring und die Verfolgung, wie sich Sentiment nach einem Launch oder einer Korrektur verschiebt.

Das ist dieselbe Art von Problem wie jeder E-Commerce-Web-Scraping-Auftrag. Der Unterschied bei Bewertungen liegt in Volumen und Paginierung: Die Daten sind über viele Seiten verteilt, werden lazy geladen und durch Anti-Bot-Abwehrmechanismen geschützt, die eskalieren, je weiter Sie gehen. Der Ansatz muss also vom ersten Request an mit Rendering, Paginierung und Blocking umgehen.

Warum ein einfacher Abruf bei Bewertungsseiten scheitert

Fordern Sie eine moderne Bewertungs-URL mit einem einfachen HTTP-Client an und Sie erhalten typischerweise Status 200 und kaum Bewertungsinhalt im Body. Zwei Dinge arbeiten gegen Sie. Erstens rendern die meisten Plattformen Bewertungen im Browser mit JavaScript, sodass das initiale HTML nur ein Skelett ist, das sich erst füllt, nachdem die Seitenskripte ausgeführt wurden. Zweitens erkennen Bewertungsseiten automatisierten Datenverkehr schnell: Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden herausgefordert oder gesperrt, bevor sie jemals den gerenderten Inhalt sehen.

Ein funktionierender Bewertungs-Scraper benötigt also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher erkennt. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender Wohnproxys zusammenstellen, aber diese zusammenzufügen und funktionsfähig zu halten, ist der Großteil der Arbeit. Die Crawlbase Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie übergeben ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt das fertige HTML zum Parsen zurück. Wenn Sie Selektoren bei gängigen Zielen überspringen möchten, gibt die Crawling API geparste Felder als JSON zurück, und für rohen Proxy-Zugriff gibt es den Smart AI Proxy.

Was Sie aus einer Bewertung extrahieren

Die zu erfassenden Felder sind plattformübergreifend konsistent, auch wenn das Markup es nicht ist. Zielen Sie auf diese fünf bei jeder Bewertungskarte ab:

• rating die Sternebewertung, normalisiert auf eine Zahl. Die meisten Seiten verwenden eine 1-bis-5-Skala; einige verwenden 1 bis 10, was Sie später umrechnen.
• title die kurze Überschrift, die ein Rezensent gibt, wenn die Plattform eine hat.
• body der Bewertungstext selbst, der qualitative Teil, der das eigentliche Signal trägt.
• date wann die Bewertung gepostet wurde, idealerweise aus einem maschinenlesbaren datetime-Attribut statt aus Anzeigetext.
• verified ob die Plattform es als verifizierten Kauf kennzeichnet, was Ihnen ermöglicht, weniger vertrauenswürdige Bewertungen später herauszufiltern.

Das Ziel ist ein stabiles Schema, sodass Bewertungen aus verschiedenen Quellen ohne quellenspezifische Bereinigung übereinstimmen. Eine einzige einheitliche Struktur funktioniert gut:

{
  "rating": 4.5,
  "title": "Exactly what I needed",
  "body": "Arrived early and works as described.",
  "date": "2026-01-10",
  "verified": true,
  "url": "https://www.example.com/product/123/reviews?page=2"
}

Sobald jede Bewertung diese Struktur hat, ist die produkt- und plattformübergreifende Analyse nur noch Filtern und Gruppieren, kein Neuformatieren.

Projekt einrichten

Sie benötigen Python 3 und ein Crawlbase-Konto mit einem JS-Token, den Sie nach der Registrierung im Dashboard erhalten. Erstellen Sie einen Projektordner und installieren Sie die Bibliotheken.

python --version

mkdir review-scraper && cd review-scraper
python -m venv venv && source venv/bin/activate
pip install crawlbase beautifulsoup4

Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML. Die Standardbibliotheksmodule re, csv und json decken Normalisierung und Speicherung ab, sodass nichts weiteres zu installieren ist. Halten Sie Ihren Token aus dem Quellcode heraus: Exportieren Sie ihn als Umgebungsvariable und lesen Sie ihn zur Laufzeit.

Das gerenderte HTML abrufen

Beginnen Sie damit, die fertige Seite abzurufen. Der Python-Client kapselt die API in einem einzigen get-Aufruf. Sie übergeben zwei Optionen, die für eine Bewertungsseite wichtig sind: ajax_wait weist die API an, auf das Laden asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, sodass spät gerenderte Bewertungskarten Zeit haben zu erscheinen. Fünf Sekunden sind ein vernünftiger Ausgangspunkt; erhöhen Sie den Wert, wenn die Ergebnisse dünn zurückkommen.

import os
from crawlbase import CrawlingAPI

# JS token renders the page in a real browser before returning HTML
api = CrawlingAPI({"token": os.environ["CRAWLBASE_JS_TOKEN"]})

options = {
    "ajax_wait": "true",
    "page_wait": 5000,
}

def fetch_html(url):
    response = api.get(url, options)
    if response["status_code"] != 200:
        raise RuntimeError(f"fetch failed: {response['status_code']}")
    return response["body"].decode("utf-8")

if __name__ == "__main__":
    url = "https://www.example.com/product/123/reviews"
    print(fetch_html(url)[:2000])

Führen Sie es aus und Sie sollten echtes Markup mit Bewertungskarten sehen, nicht die leere Hülle, die ein einfacher Abruf zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben. response["body"] kommt als Bytes vom Client zurück; dekodieren Sie es einmal und übergeben Sie den String an den Parser.

Bewertungen mit BeautifulSoup parsen

Mit dem HTML laden Sie es in BeautifulSoup und durchlaufen die Bewertungskarten. Jede Karte trägt die gewünschten Felder, aber die Klassennamen unterscheiden sich je nach Plattform, sodass der Parser eine Liste von Kandidaten-Selektoren verwendet und den ersten nimmt, der passt. Überprüfen Sie die Live-Seite in den Entwicklertools Ihres Browsers, um die aktuellen Selektoren für Ihr Ziel zu finden, und ordnen Sie jedes Feld einem zu.

import re
from bs4 import BeautifulSoup

def first_text(card, selectors):
    for sel in selectors:
        el = card.select_one(sel)
        if el:
            return el.get_text(separator=" ", strip=True)
    return ""

def parse_reviews(html, source_url=""):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("[data-review-id], article[class*='review'], .review-card")
    reviews = []
    for card in cards:
        rating_raw = first_text(card, ["[data-rating]", ".star-rating", "[class*='star']"])
        match = re.search(r"(\d+(?:\.\d+)?)", rating_raw)
        date_el = card.select_one("time[datetime], [data-review-date]")
        reviews.append({
            "rating": float(match.group(1)) if match else None,
            "title": first_text(card, [".review-title", "h3", "[class*='title']"]),
            "body": first_text(card, [".review-body", "[data-review-text]", "p"]),
            "date": (date_el.get("datetime") if date_el else ""),
            "verified": card.select_one("[class*='verified']") is not None,
            "url": source_url,
        })
    return [r for r in reviews if r["body"]]

Der first_text-Helfer macht den Parser portabel: Geben Sie ihm eine kurze Liste wahrscheinlicher Selektoren pro Feld und er gibt den ersten Treffer zurück, sodass die Anpassung an eine neue Plattform hauptsächlich das Bearbeiten dieser Listen statt das Umschreiben der Logik ist. Das Herausfiltern von Bewertungen mit einem leeren body filtert Layout-Karten und Werbeplätze heraus, die die Klasse des Bewertungscontainers teilen.

Durch alle Bewertungen paginieren

Eine Seite abzurufen reicht selten aus. Die meisten Plattformen verteilen Bewertungen über Dutzende oder Hunderte von Seiten, meist mit einem ?page=2-Abfrageparameter. Wenn Sie nur die erste Seite anfordern, entgeht Ihnen die Mehrheit der Daten. Das Muster besteht darin, Seiten-URLs in einer Schleife aufzubauen, jede abzurufen und zu parsen und zu stoppen, wenn eine Seite keine Bewertungen zurückgibt oder Sie ein von Ihnen gesetztes Limit erreichen.

import time

def scrape_all_reviews(base_url, max_pages=25):
    all_reviews = []
    for page in range(1, max_pages + 1):
        sep = "&" if "?" in base_url else "?"
        page_url = f"{base_url}{sep}page={page}"
        html = fetch_html(page_url)
        reviews = parse_reviews(html, page_url)
        if not reviews:
            break  # empty page means we ran past the last one
        all_reviews.extend(reviews)
        print(f"page {page}: {len(reviews)} reviews")
        time.sleep(1)  # pace requests so you stay under rate limits
    return all_reviews

Einige praktische Hinweise. Setzen Sie ein sinnvolles max_pages, damit eine Layout-Änderung Sie nicht in eine Endlosschleife schicken kann. Stoppen Sie, sobald eine Seite null Bewertungen liefert. Und wenn Ihr Ziel Infinite Scroll statt nummerierten Seiten verwendet, geben Sie die Option scroll in das Crawling-API-options-Dict statt Seiten-URLs zu bauen; der Rest der Schleife bleibt gleich.

Plattformübergreifend normalisieren

Für ein einzelnes Produkt auf einer Plattform ist die Parser-Ausgabe in der Regel sauber genug, um sie direkt zu speichern. Sobald Sie Bewertungen von mehr als einer Quelle ziehen, tauchen kleine Inkonsistenzen auf: Eine Seite bewertet auf 10, eine andere verwendet relative Daten wie „vor 3 Tagen", und Feldnamen weichen ab. Ein schlanker Normalisierungsschritt hält alles vergleichbar.

def normalize(review, scale=5):
    rating = review.get("rating")
    if rating is not None and scale != 5:
        # map any scale onto a common 0-5 range
        review["rating"] = round(rating / scale * 5, 2)
    review["body"] = " ".join(review["body"].split())
    return review

Bewertungen auf eine Skala umrechnen, Leerzeichen im Body zusammenfassen und Feldnamen angleichen, wenn eine Quelle die Dinge anders benennt. Für eine einzelne Plattform können Sie diesen Schritt überspringen; für die plattformübergreifende Analyse verhindert er, dass die Daten auseinanderdriften.

Ergebnisse speichern

Das Loggen in die Konsole ist beim Iterieren gut, aber Sie möchten die Daten auf der Festplatte haben. CSV ist das einfachste Ziel und öffnet sich in jeder Tabellenkalkulation; das Standardbibliotheksmodul csv bildet jeden Dict-Schlüssel auf eine Spalte ab.

import csv

def save_csv(reviews, path="reviews.csv"):
    fields = ["rating", "title", "body", "date", "verified", "url"]
    with open(path, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fields)
        writer.writeheader()
        writer.writerows(reviews)
    print(f"saved {len(reviews)} reviews to {path}")

Wenn Sie die Daten lieber mit SQL abfragen möchten, schreiben Sie dieselben Zeilen mit dem Standardbibliotheksmodul sqlite3 in eine SQLite-Tabelle; Parsing und Paginierung bleiben identisch. JSON Lines ist eine weitere gute Option, wenn Sie Datensätze in eine nachgelagerte Pipeline streamen möchten. Verbinden Sie die Teile und der gesamte Lauf ist nur wenige Aufrufe:

if __name__ == "__main__":
    base = "https://www.example.com/product/123/reviews"
    reviews = scrape_all_reviews(base, max_pages=25)
    reviews = [normalize(r) for r in reviews]
    save_csv(reviews)

Optional: Sentiment auf den Body-Text anwenden

Sobald Bewertungen strukturiert sind, ist Sentiment ein kurzer Add-on. Ein leichtes, regelbasiertes Modell wie VADER gibt Ihnen einen Polaritätswert pro Bewertung, ohne etwas zu trainieren, was ausreicht, um die wütendsten und glücklichsten Bewertungen zu kennzeichnen und das durchschnittliche Sentiment über die Zeit zu verfolgen.

# pip install vaderSentiment
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

analyzer = SentimentIntensityAnalyzer()

def add_sentiment(reviews):
    for r in reviews:
        score = analyzer.polarity_scores(r["body"])["compound"]
        r["sentiment"] = round(score, 3)
    return reviews

Der compound-Wert reicht von -1 (sehr negativ) bis +1 (sehr positiv). Für tiefgreifendere Arbeit übergeben Sie denselben Body-Text an einen transformer-basierten Klassifikator oder einen gehosteten NLP-Dienst; die Pipeline bis zu diesem Punkt ändert sich nicht.

Auf viele Produkte skalieren

Eine Schleife und ein Sleep reicht für ein Produkt. Wenn Sie Bewertungen über Hunderte von URLs benötigen, kämpfen Sie in Ihrem eigenen Code mit Parallelität, Wiederholungsversuchen und Scheduling. Da kommt der Crawler ins Spiel: Anstatt Seiten einzeln abzurufen, senden Sie eine Liste von URLs an Crawlbase und es verarbeitet sie in der Cloud, rendert jede Seite und liefert das fertige HTML an Ihren Endpunkt über einen Webhook. Fehlgeschlagene Anfragen werden für Sie wiederholt, sodass Sie keine Warteschlange beaufsichtigen müssen. Für eine Handvoll Seiten reicht die Crawling API; darüber hinaus beseitigt der Crawler den größten Teil des operativen Aufwands.

Nicht blockiert werden

Selbst wenn das Rendering gehandhabt wird, achten Bewertungsseiten auf Scraper-artigen Datenverkehr. Einige Gewohnheiten halten einen Lauf gesund und gelten für jedes schwierige kommerzielle Ziel.

• Anfragen dosieren. Die Bewertungen desselben Produkts in einer engen Schleife zu hämmern ist der schnellste Weg zu Drosselung. Das time.sleep in der Paginierungsschleife ist bewusst gesetzt; behalten Sie es.
• Rotation nutzen. Ein Pool von Wohnproxys verteilt Anfragen über viele echte Nutzer-IPs, sodass keine einzelne Adresse ein Ratenlimit auslöst. Die Crawling API erledigt das für Sie; wenn Sie einen eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Statuscodes beachten. Ein Lauf, der beginnt, Challenges oder Fehler zurückzuliefern, signalisiert Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie den Antwortstatus als Signal, nicht als Rauschen, und rudern Sie zurück, wenn er sich ändert.

Für das umfassendere Vorgehen lesen Sie wie Sie Websites scrapen, ohne gesperrt zu werden. Wenn Sie diesen verwalteten Ansatz mit einem selbst erstellten Headless-Stack vergleichen möchten, führt Web Scraping mit Python und Selenium durch diesen Aufbau.

Der ehrliche Teil: AGB und personenbezogene Daten

Das Scrapen einer großen kommerziellen Website befindet sich in einer rechtlichen Grauzone, und ob es erlaubt ist, hängt von den Nutzungsbedingungen der Plattform, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten tun. Viele Bewertungsseiten schränken automatisierten Zugriff in ihren Bedingungen ein, sodass das Scrapen gegen diese Bedingungen verstoßen kann, egal wie sorgfältig Ihr Tooling ist. Keiner der hier verwendeten Code ändert das; er macht nur den technischen Teil funktionsfähig.

Einige Grundsätze, an denen es sich lohnt festzuhalten. Sammeln Sie nur öffentliche Bewertungen: Bewertung, Titel, Body, Datum und Verifizierungsabzeichen, die jeder ohne Konto sehen kann. Respektieren Sie die robots.txt der Website und ihre formulierten Ratenerwartungen und halten Sie Ihr Anfragevolumen niedrig genug, sodass Sie niemandes Server belasten. Sammeln Sie keine personenbezogenen Daten über das hinaus, was die Plattform bereits öffentlich anzeigt, und versuchen Sie niemals, einen Rezensenten zu de-anonymisieren oder seine Bewertungen mit Daten von anderswo zu verknüpfen. Wenn Sie die Daten kommerziell wiederverwenden möchten, holen Sie eine Erlaubnis oder einen offiziellen Datenvertrag ein, anstatt anzunehmen, dass Schweigen Zustimmung bedeutet.

Dieser Leitfaden beschränkt sich bewusst auf öffentliche Bewertungsinhalte, da das die Linie ist, die die Arbeit verteidigbar macht. Er deckt nichts hinter einem Login, Konto- oder Profildaten oder Aktionen als angemeldeter Nutzer ab. Wenn Ihr Projekt mehr als öffentliche Bewertungen benötigt, ist der richtige Weg eine offizielle API oder ein Datenvertrag mit der Plattform, nicht ein ausgefeilterer Scraper. Für Hintergrundinformationen zum Unterschied zwischen verwaltetem Zugriff und rohem Scraping ist E-Commerce-Web-Scraping eine nützliche ergänzende Lektüre.

Häufig gestellte Fragen

Wie scrappe ich Kundenbewertungen von JavaScript-intensiven Websites?

Die meisten Bewertungsplattformen rendern ihre Karten clientseitig, sodass eine einfache HTTP-Anfrage Status 200 zurückgibt, während die Bewertungen fehlen. Sie benötigen einen browser-basierten Abruf. Senden Sie die URL an die Crawling API mit einem JS-Token und sie rendert die Seite in einem echten Browser, bevor sie das HTML zurückgibt, sodass jede Bewertung vorhanden ist, wenn BeautifulSoup sie parst. Die Optionen ajax_wait und page_wait steuern, wie lange sie auf spät geladene Inhalte wartet.

Benötige ich den normalen Token oder den JS-Token zum Scrapen von Kundenbewertungen?

Den JS-Token. Der normale Token ruft statisches HTML ab, das auf einer Bewertungsseite dieselbe leere Hülle ist wie bei einem einfachen Abruf. Der JS-Token rendert die Seite zuerst in einem echten Browser, sodass die Bewertungskarten im HTML vorhanden sind, wenn Ihr Parser ausgeführt wird.

Wie erhalte ich alle Bewertungen und nicht nur die erste Seite?

Die meisten Plattformen paginieren mit einem ?page=2-Parameter. Erstellen Sie die Seiten-URLs in einer Schleife, rufen und parsen Sie jede einzeln und stoppen Sie, wenn eine Seite keine Bewertungen zurückgibt oder Sie ein von Ihnen gesetztes Limit erreichen. Für Seiten, die Infinite Scroll statt nummerierten Seiten verwenden, übergeben Sie die scroll-Option der Crawling API statt Seiten-URLs zu bauen; der Rest der Schleife bleibt gleich.

Meine Selektoren liefern leere Felder. Was hat sich geändert?

Fast sicher das Markup der Plattform. Bewertungsseiten ändern ihre Klassennamen und Datenattribute ohne Vorankündigung, sodass Selektoren, die letzten Monat funktionierten, kaputtgehen können. Überprüfen Sie eine Live-Bewertungsseite in den Entwicklertools Ihres Browsers und aktualisieren Sie die Kandidaten-Selektor-Listen im Parser. Regelmäßige Selektor-Wartung ist für jeden produktiven Scraper normal.

Kann ich Sentiment-Analyse auf die gescrapten Bewertungen anwenden?

Ja. Sobald Bewertungen in ein konsistentes Schema normalisiert sind, fließt der Body-Text direkt in einen NLP-Schritt. Ein regelbasiertes Modell wie VADER gibt Ihnen einen Polaritätswert pro Bewertung ohne Training; für mehr Nuancen übergeben Sie denselben Text an einen Transformer-Klassifikator oder einen gehosteten NLP-Dienst. Die Scraping-Pipeline ändert sich nicht.

Ist es legal, Kundenbewertungen zu scrapen?

Das hängt von den Nutzungsbedingungen der Plattform, Ihrer Rechtsordnung und Ihrem Zweck ab, und viele Seiten schränken automatisierten Zugriff ein. Bleiben Sie strikt bei öffentlichen Bewertungsinhalten, respektieren Sie robots.txt und Ratenerwartungen und sammeln Sie keine personenbezogenen Daten über das öffentlich Angezeigte hinaus oder versuchen Sie, einzelne Rezensenten zu identifizieren. Für kommerzielle Nutzung holen Sie eine Erlaubnis oder einen offiziellen Datenvertrag ein, anstatt auf einen Scraper zu setzen.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.

NZ

Neil Zamora

Senior Architect · Crawlbase

Senior Architect bei Crawlbase mit Fokus auf den Systemen hinter großflächigem Crawling: Proxy-Rotation, Anti-Bot-Resilienz und den APIs, die diese Komplexität verbergen.