Amazon-Bewertungen scrapenBewertungen, Text und Sentiment

Amazon-Produktbewertungen sind eines der reichhaltigsten öffentlichen Signale im offenen Web. Die Sternebewertung, der Titel, der Bewertungstext und das Datum auf jeder Bewertung ergeben zusammen ein laufendes Protokoll dessen, was echte Käufer über ein Produkt denken. Diese Daten treiben Sentiment-Analysen, Produktforschung und Wettbewerbsvergleiche an, weshalb Teams einen sauberen, strukturierten Feed davon wollen, statt die Seite von Hand zu scrollen.

Dieser Leitfaden zeigt Ihnen, wie Sie Amazon-Bewertungen mit Python scrapen. Sie bauen einen kleinen, lauffähigen Scraper, der die Bewertungsseite eines Produkts über die Crawling API abruft, jede Bewertung mit BeautifulSoup parst, die Paginierung durchläuft und die Ergebnisse in JSON und CSV exportiert. Das gesamte Tutorial beschränkt sich auf den öffentlichen Bewertungstext, den Amazon jedem Besucher zeigt, und der Abschnitt zur Rechtslage am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf echtes Volumen loslassen.

Was Sie bauen werden

Ein Python-Skript, das die Bewertungs-URL eines Amazon-Produkts nimmt, die gerenderte Seite über die Crawling API abruft und einen strukturierten Datensatz pro Bewertung extrahiert. Als laufendes Beispiel verwenden wir die Meta Quest Pro und ziehen diese Felder aus jedem Bewertungsblock:

• Bewertungsname der auf der Bewertung angezeigte öffentliche Anzeigename.
• Bewertung die Sternebewertung, z. B. "4.0 out of 5 stars".
• Titel die kurze Überschrift, die der Bewerter der Bewertung gegeben hat.
• Bewertungstext die vollständige schriftliche Bewertung.
• Datum die Zeile "Reviewed in the United States on ...".

Das Skript sammelt diese Datensätze über jede Seite der Bewertungen und schreibt sie in amazon_reviews.json und amazon_reviews.csv, bereit für ein Sentiment-Modell, eine Tabellenkalkulation oder eine Datenbank.

Warum eine einfache Anfrage bei Amazon scheitert

Wenn Sie einen einfachen HTTP-Client auf eine Amazon-Bewertungs-URL richten, erhalten Sie selten die Bewertungen. Amazon ist eine der am stärksten gegen automatisierten Traffic abgesicherten Websites im Web. Eine Rechenzentrums-IP oder eine Anfrage, die nicht wie ein echter Browser aussieht, wird mit einem CAPTCHA, einem "Robot Check"-Interstitial oder einer direkten Sperre konfrontiert, bevor Sie die Bewertungsblöcke erreichen. Selbst wenn eine Anfrage durchkommt, rendert ein Teil der Seite über JavaScript, sodass ein roher Fetch eine Hülle statt fertigem Markup zurückgeben kann.

Ein funktionierender Amazon-Bewertungs-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Käufer liest. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender Residential Proxys zusammenbauen, aber das Zusammenfügen und Gesundhalten dieser Teile ist der Hauptteil der Arbeit. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie senden die URL, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP, rotiert Adressen für Sie und gibt fertiges HTML zurück, damit BeautifulSoup es parsen kann.

Voraussetzungen

Bevor Sie Code schreiben, müssen einige Dinge eingerichtet sein. Keines davon dauert lange.

Python-Grundkenntnisse. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen und Pakete mit pip zu installieren. Wenn Sie neu in der Sprache sind, bringen Sie der Primer Website mit Python scrapen und ein beliebiger Einsteigerkurs auf das Niveau, das dieses Tutorial voraussetzt.

Python 3.8 oder neuer. Überprüfen Sie Ihre Version mit python --version. Falls nicht vorhanden, installieren Sie Python von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Kontodokumentationsseite. Crawlbase gibt Ihnen bis zu 20.000 kostenlose Anfragen zum Start ohne Kreditkarte, und Sie zahlen nur für erfolgreiche Anfragen. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionsverwaltung heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv amazon_env
source amazon_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit amazon_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten übernehmen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, sodass Sie jedes Feld per CSS-Selektor aus einem Bewertungsblock herausziehen können.

Die Amazon-Bewertungsseite verstehen

Bevor Sie Selektoren schreiben, öffnen Sie die Bewertungsseite eines Produkts in Ihrem Browser, klicken Sie mit der rechten Maustaste auf eine einzelne Bewertung und wählen Sie Untersuchen. Amazon kapselt jede Bewertung in einem Container, der mit data-hook="review" markiert ist, und exponiert die einzelnen Felder über stabile data-hook-Attribute innerhalb dieses Containers. Diese Hooks sind weit beständiger als Amazons Hilfsklassennamen, sodass Sie sie verwenden sollten, wo immer möglich.

Die Felder, die Sie interessieren, sind diesen Hooks innerhalb jedes Bewertungsblocks zugeordnet:

• Bewertungsname das Element span.a-profile-name.
• Bewertung [data-hook="review-star-rating"] (oder review-star-rating-view-point bei einigen Layouts).
• Titel [data-hook="review-title"].
• Bewertungstext [data-hook="review-body"].
• Datum [data-hook="review-date"].

Schritt 1: Die gerenderte Bewertungsseite abrufen

Beginnen Sie damit, die fertige Seite zu laden. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem Token, richten Sie sie auf die Bewertungs-URL eines Produkts und fragen Sie es ab. Das Prüfen des Status-Codes vor dem Parsen hält Fehler laut statt stumm.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

REVIEWS_URL = (
    "https://www.amazon.com/Meta-Quest-Pro-Oculus/product-reviews/"
    "B09Z7KGTVW/?reviewerType=all_reviews"
)

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    html = crawl(REVIEWS_URL)
    print(html[:500] if html else "No HTML returned")

Die zwei Warte-Optionen helfen, wenn Teile der Seite asynchron laden. ajax_wait weist die API an, auf das Abschließen asynchroner Inhalte zu warten, und page_wait hält nach dem Laden für eine feste Anzahl von Millisekunden an, damit spät rendernde Bewertungsblöcke erscheinen, bevor die Seite erfasst wird. Der Body wird als latin1 dekodiert, weil Amazon-Seiten Zeichen enthalten können, an denen strenge UTF-8-Dekodierung scheitert. Führen Sie das Skript aus und Sie sollten echtes Bewertungs-Markup sehen, keine Robot-Check-Seite. Das bestätigt, dass die Anfrage durchkommt, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Bewertungen mit BeautifulSoup parsen

Mit dem gerenderten HTML laden Sie es in BeautifulSoup, finden jeden Bewertungsblock und ziehen jedes Feld per data-hook-Selektor heraus. Kapseln Sie jeden Block in einem try/except, damit eine fehlerhafte Bewertung den Lauf nicht zum Absturz bringt.

from bs4 import BeautifulSoup

def text_of(block, selector):
    el = block.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_reviews(html):
    soup = BeautifulSoup(html, "html.parser")
    blocks = soup.select('div[data-hook="review"]')
    reviews = []
    for block in blocks:
        try:
            reviews.append({
                "reviewer_name": text_of(block, "span.a-profile-name"),
                "rating": text_of(block, '[data-hook="review-star-rating"]'),
                "title": text_of(block, '[data-hook="review-title"]'),
                "text": text_of(block, '[data-hook="review-body"]'),
                "date": text_of(block, '[data-hook="review-date"]'),
            })
        except Exception as e:
            print(f"Skipped a review: {e}")
    return reviews

Der Helfer text_of fragt ein einzelnes Element innerhalb eines Bewertungsblocks ab und gibt None zurück, wenn das Element fehlt, statt bei einem .get_text()-Aufruf auf nichts zu werfen. Das macht die Extraktion robust, wenn ein Feld fehlt. Der Sternebewertungs-Selektor fällt elegant zurück: Wenn review-star-rating bei einem bestimmten Layout nichts zurückgibt, tauschen Sie ihn gegen review-star-rating-view-point, das Amazon auf einigen Seiten verwendet. Die Bewertung kommt als String wie "4.0 out of 5 stars"; teilen Sie ihn bei " out of" auf, wenn Sie später einen numerischen Rohwert für ein Modell möchten.

Schritt 3: Die Bewertungs-Paginierung durchlaufen

Eine Seite ist ein Demo; ein echter Job läuft über jede Bewertungsseite eines Produkts. Amazon paginiert Bewertungen mit einem pageNumber-Query-Parameter, sodass Sie Seiten durchlaufen, indem Sie ihn erhöhen und anhalten, wenn eine Seite keine Bewertungsblöcke zurückgibt. Das vermeidet das Hardcoding einer Seitenanzahl und behandelt natürlich Produkte mit nur einer Handvoll Bewertungen.

Um das Muster zu sehen, vergleichen Sie die URLs, die Amazon verwendet:

• Seite 1 .../product-reviews/B09Z7KGTVW/?reviewerType=all_reviews
• Seite 2 .../product-reviews/B09Z7KGTVW/?reviewerType=all_reviews&pageNumber=2
• Seite 3 .../product-reviews/B09Z7KGTVW/?reviewerType=all_reviews&pageNumber=3

import time

def scrape_all_reviews(base_url, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        page_url = f"{base_url}&pageNumber={page}"
        html = crawl(page_url)
        if not html:
            break
        reviews = parse_reviews(html)
        if not reviews:
            print(f"No reviews on page {page}; stopping.")
            break
        all_reviews.extend(reviews)
        print(f"Page {page}: {len(reviews)} reviews")
        time.sleep(2)
    return all_reviews

Die max_pages-Begrenzung hält einen Lauf begrenzt, damit ein Produkt mit Tausenden von Bewertungen nicht ewig spinnt, und der Leer-Ergebnis-Break stoppt Sie früh, wenn Amazon die Seiten aufgebraucht hat. Das time.sleep(2) zwischen Seiten bremst Anfragen, damit Sie die Seite nicht in einer engen Schleife hämmern, was der schnellste Weg ist, gedrosselt zu werden. Passen Sie beide an Ihr Volumen und die unten beschriebenen Rate-Limits an.

Schritt 4: Die Daten zusammensetzen und speichern

Verbinden Sie nun den Fetch, das Parsen und die Paginierung zu einem lauffähigen Skript und schreiben Sie dann die gesammelten Bewertungen in JSON und CSV. JSON bewahrt die verschachtelte Struktur für eine Pipeline; CSV fällt direkt in eine Tabellenkalkulation oder einen pandas-DataFrame für Sentiment-Arbeit.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

REVIEWS_URL = (
    "https://www.amazon.com/Meta-Quest-Pro-Oculus/product-reviews/"
    "B09Z7KGTVW/?reviewerType=all_reviews"
)

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(block, selector):
    el = block.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_reviews(html):
    soup = BeautifulSoup(html, "html.parser")
    blocks = soup.select('div[data-hook="review"]')
    reviews = []
    for block in blocks:
        try:
            reviews.append({
                "reviewer_name": text_of(block, "span.a-profile-name"),
                "rating": text_of(block, '[data-hook="review-star-rating"]'),
                "title": text_of(block, '[data-hook="review-title"]'),
                "text": text_of(block, '[data-hook="review-body"]'),
                "date": text_of(block, '[data-hook="review-date"]'),
            })
        except Exception as e:
            print(f"Skipped a review: {e}")
    return reviews

def scrape_all_reviews(base_url, max_pages=10):
    all_reviews = []
    for page in range(1, max_pages + 1):
        page_url = f"{base_url}&pageNumber={page}"
        html = crawl(page_url)
        if not html:
            break
        reviews = parse_reviews(html)
        if not reviews:
            break
        all_reviews.extend(reviews)
        print(f"Page {page}: {len(reviews)} reviews")
        time.sleep(2)
    return all_reviews

def save(reviews):
    with open("amazon_reviews.json", "w", encoding="utf-8") as f:
        json.dump(reviews, f, indent=2, ensure_ascii=False)
    if reviews:
        with open("amazon_reviews.csv", "w", newline="", encoding="utf-8") as f:
            writer = csv.DictWriter(f, fieldnames=reviews[0].keys())
            writer.writeheader()
            writer.writerows(reviews)
    print(f"Saved {len(reviews)} reviews to JSON and CSV")

def main():
    reviews = scrape_all_reviews(REVIEWS_URL)
    save(reviews)

if __name__ == "__main__":
    main()

Führen Sie es mit python scraper.py aus. Das Skript durchläuft die Bewertungsseiten, gibt eine Pro-Seite-Anzahl aus und schreibt amazon_reviews.json und amazon_reviews.csv im selben Verzeichnis. Von dort fließen die Datensätze in ein Sentiment-Modell, ein Bewertungs-Trend-Diagramm oder einen Vergleich mit dem Produkt eines Konkurrenten. Bevor Sie das tun, lohnt es sich, die Daten durch einen Pass zum Strukturieren und Bereinigen von Web-Scraping-Daten für KI und ML zu schicken, damit Bewertungen und Daten in konsistenten Typen landen.

Wie die Ausgabe aussieht

Jeder Datensatz ist ein flaches Objekt mit den fünf Feldern. Die JSON-Datei sieht so aus:

[
  {
    "reviewer_name": "Grrgoyl",
    "rating": "4.0 out of 5 stars",
    "title": "No regret",
    "text": "My 256 gb Quest 2 is in danger of running out of space, so the Pro was an easy call.",
    "date": "Reviewed in the United States on August 2, 2023"
  },
  {
    "reviewer_name": "Damian",
    "rating": "3.0 out of 5 stars",
    "title": "Excellent comfort, poor display",
    "text": "I purchased this to upgrade from my first gen Rift and the comfort is great, the display less so.",
    "date": "Reviewed in the United States on November 1, 2022"
  }
]

Die CSV trägt dieselben fünf Spalten: reviewer_name, rating, title, text und date. Wenn Sie das Parsen vollständig überspringen möchten, gibt die Crawling API diese Felder vorgelöst als JSON über ihren amazon-product-reviews-Parser zurück, der auch Extras wie die Bewertungs-ID und das Verified-Purchase-Flag liefert.

Nicht gesperrt bleiben

Selbst mit Rendering und Rotation, die für Sie erledigt werden, achtet Amazon auf Scraper-ähnlichen Traffic. Einige Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes schwierige kommerzielle Ziel.

• Drosseln Sie Ihre Anfragen. Verteilen Sie Anfragen mit einer Verzögerung zwischen Seiten, statt mit voller Geschwindigkeit zu crawlen. Das time.sleep in der Paginierungsschleife ist der Boden, nicht die Decke.
• Setzen Sie auf Rotation. Ein Pool von Residential IPs verteilt Anfragen über viele echte Nutzer-Adressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Lesen Sie die Status-Codes. Ein Lauf, der beginnt, Herausforderungen oder Fehler zurückzugeben, teilt Ihnen mit, dass die aktuelle Rate oder IP-Tier nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückziehen, nicht als Rauschen, das ignoriert werden soll.

Das breitere Spielbuch finden Sie in Wie man Websites scrapt, ohne gesperrt zu werden. Wenn Ihr Interesse dem vollständigen Bewertungsbild über mehr als einen Händler gilt, behandelt der allgemeine Leitfaden Wie man Kundenbewertungen scrapt die plattformübergreifenden Muster, und Amazon-Produktdaten scrapen passt gut, wenn Sie Angebotsdaten neben den Bewertungen möchten.

Ist es legal, Amazon-Bewertungen zu scrapen?

Ob das Scrapen von Amazon-Bewertungen erlaubt ist, hängt von Amazons Nutzungsbedingungen, Ihrer Rechtsprechung und der Verwendung der Daten ab. Amazons Nutzungsbedingungen beschränken den automatisierten Zugriff, sodass das Scrapen gegen diese Bedingungen verstoßen kann, unabhängig davon, wie sorgfältig Ihr Tooling ist. Kein Code hier ändert das; er macht nur den technischen Teil funktionieren. Lesen Sie Amazons Nutzungsbedingungen und seine robots.txt und behandeln Sie beide als Grenze dessen, was Sie sammeln. Amazon betreibt auch CAPTCHA-Herausforderungen, um zu bestätigen, dass ein Mensch surft, was Teil derselben defensiven Haltung ist.

Einige Linien, die es wert sind einzuhalten. Sammeln Sie nur den öffentlichen Bewertungstext: die Bewertung, den Titel, den Body und das Datum, das jeder Besucher auf der Bewertungsseite ohne Konto lesen kann. Der auf einer Bewertung angezeigte Bewertungsname ist öffentlich, aber ein Anzeigename ist das Maximum, das Sie jemals behalten sollten. Erstellen Sie keine Profile einzelner Bewerter, folgen Sie keinen Profillinks, um die Bewertungshistorie einer Person über Produkte hinweg zusammenzustellen, und versuchen Sie nicht, einen Anzeigenamen mit einer echten Identität zu verknüpfen. Respektieren Sie die Privatsphäre und behandeln Sie jede Bewertung als Datenpunkt über das Produkt, nicht über eine Person.

Dieser Leitfaden beschränkt sich bewusst auf öffentliche Bewertungsseiten, weil das die Linie ist, die die Arbeit vertretbar hält. Er deckt nichts hinter einem Login ab, keine Konto- oder Bestelldaten und keinen Versuch, Authentifizierung zu umgehen, und er verbreitet keine urheberrechtlich geschützten Bewertungsmedien. Wenn Sie lizenzierten oder Massen-Zugriff benötigen, bietet Amazon offizielle APIs und Partner-Programme für Produkt- und Bewertungsdaten, und das ist das richtige Werkzeug, wenn Sie große Volumina, garantierte Struktur oder kommerzielle Rechte benötigen. Wenn Ihr Projekt mehr als öffentlichen Bewertungstext benötigt, ist eine offizielle API oder eine Datenvereinbarung der richtige Weg, kein cleverer Scraper.

Häufig gestellte Fragen

Warum scheitert eine einfache Anfrage bei Amazon-Bewertungen?

Amazon verteidigt sich hart gegen automatisierten Traffic. Eine Rechenzentrums-IP oder eine Anfrage, die nicht wie ein echter Browser aussieht, wird mit einem CAPTCHA, einem Robot-Check-Interstitial oder einer Sperre konfrontiert, bevor sie die Bewertungsblöcke erreicht, und Teile der Seite rendern zusätzlich über JavaScript. Die Crawling API rendert die Seite hinter einer vertrauenswürdigen Residential-IP, sodass die Bewertungen vorhanden sind, wenn BeautifulSoup sie parst.

Welche Felder kann ich aus einer Amazon-Bewertung extrahieren?

Dieser Scraper zieht den öffentlichen Anzeigenamen des Bewerters, die Sternebewertung, den Bewertungstitel, den Body-Text und das Datum heraus. Jedes ist einem data-hook-Attribut innerhalb des Bewertungsblocks zugeordnet: review-star-rating, review-title, review-body und review-date, plus span.a-profile-name für den Namen. Der amazon-product-reviews-Parser der Scraper API gibt dieselben Felder plus Extras wie die Bewertungs-ID und ein Verified-Purchase-Flag zurück.

Wie scrappe ich jede Bewertungsseite?

Amazon paginiert Bewertungen mit einem pageNumber-Query-Parameter auf der product-reviews-URL. Erhöhen Sie ihn in einer Schleife, parsen Sie jede Seite mit demselben Code und hören Sie auf, wenn eine Seite keine Bewertungsblöcke zurückgibt. Begrenzen Sie die Seitenanzahl und fügen Sie zwischen Anfragen eine kurze Verzögerung hinzu, damit Sie den Lauf bremsen und nicht gedrosselt werden.

Meine Selektoren geben None zurück. Was hat sich geändert?

Fast sicher Amazons Markup. Seine Hilfsklassennamen ändern sich ohne Vorankündigung, weshalb die obigen Selektoren auf data-hook-Attribute abzielen. Wenn die Sternebewertung leer zurückkommt, versuchen Sie review-star-rating-view-point, das Amazon auf einigen Layouts verwendet. Untersuchen Sie eine Live-Bewertungsseite in den Dev-Tools Ihres Browsers und aktualisieren Sie den Selektor; periodische Wartung ist bei jedem Produktions-Scraper normal.

Kann ich die gescrapten Bewertungen für Sentiment-Analysen verwenden?

Ja, das ist einer der häufigsten Gründe, sie zu sammeln. Exportieren Sie in CSV, laden Sie es in pandas und führen Sie den Body-Text durch ein Sentiment-Modell oder eine Bewertungs-Trendanalyse. Bereinigen Sie zuerst die Bewertung in einen numerischen Wert und parsen Sie das Datum in einen echten Datumstyp, damit die Felder modellbereit sind.

Ist es sicher, Bewertungsnamen zu speichern?

Halten Sie es minimal. Der Anzeigename auf einer öffentlichen Bewertung ist öffentlich, aber er ist das Maximum, das Sie behalten sollten, und Sie sollten ihn niemals verwenden, um ein Profil eines einzelnen Bewerters zu erstellen oder einen Namen mit einer echten Identität zu verknüpfen. Behandeln Sie jede Bewertung als Datenpunkt über das Produkt, respektieren Sie die Privatsphäre und prüfen Sie Amazons Bedingungen und Ihre lokalen Datenschutzregeln, bevor Sie ein persönliches Feld speichern.

MA

Muhammad Atif

Senior Full Stack Developer · Crawlbase

Senior Full Stack Developer bei Crawlbase, der die Plattform aufbaut und über Scraping-Architektur, Proxys und Datenpipelines schreibt.

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.