So scrape ich Amazon-Bewertungen mit Python – trotz Login-Sperre

Mein Amazon-Bewertungs-Scraper lief sechs Wochen lang völlig problemlos – und dann kam eines Morgens nur noch 200 OK zurück, aber statt Rezensionen war die Seite leer. Kein Fehler, kein CAPTCHA, nur schlichtes HTML ohne Inhalt, wo zuvor Hunderte von Bewertungen standen.

Falls dir das bekannt vorkommt: Du bist nicht allein. Ende 2025 hat Amazon seine vollständigen Bewertungsseiten hinter eine Login-Sperre gesetzt, und dadurch sind unzählige Python-Skripte über Nacht ausgefallen. Ich habe die letzten Monate bei von beiden Seiten aus an diesem Problem gearbeitet – wir entwickeln unseren AI Scraper und ich betreibe gleichzeitig meine eigene Python-Pipeline für Bewertungen. Deshalb wollte ich genau den Leitfaden schreiben, den ich selbst gebraucht hätte, als mein Skript plötzlich nicht mehr funktionierte. In diesem Beitrag zeige ich den Ansatz, der tatsächlich funktioniert: Cookie-basierte Authentifizierung, stabile Selektoren, die Amazons CSS-Verschleierung überstehen, Workarounds für das 10-Seiten-Limit, Anti-Bot-Maßnahmen und als Bonus einen Sentiment-Analyse-Teil, der rohe Rezensionen in echte Business-Insights verwandelt. Und wenn du unterwegs denkst: „Eigentlich will ich diesen ganzen Code nicht warten“, zeige ich dir auch, wie dieselbe Aufgabe in etwa zwei Minuten ganz ohne Python erledigt.

Was ist Amazon Review Scraping – und warum ist es wichtig?

Amazon Review Scraping bezeichnet das programmatische Auslesen von Kundenbewertungen – also Sternebewertungen, Bewertungstext, Autorennamen, Datum, Hinweise auf verifizierte Käufe und mehr – direkt von Amazon-Produktseiten. Da Amazon die Bewertungsinhalte bereits 2010 aus seiner und nie wieder zurückgebracht hat, bleibt Web Scraping der einzige programmatische Weg zu diesen Daten.

Die Zahlen sprechen für sich. , und . Schon 5 Bewertungen auf einer Produktseite können die . Unternehmen, die Bewertungsstimmungen systematisch analysieren, sehen . Das ist keine abstrakte Data-Science-Spielerei – das sind Wettbewerbsinformationen, Signale für Produktverbesserungen und Marketing-Sprache, direkt im Klartext auf Amazons Servern.

Warum Amazon-Bewertungen mit Python scrapen?

Python bleibt für diese Aufgabe die erste Wahl. Es ist die , und das Ökosystem rund um requests, BeautifulSoup, pandas und Scrapy macht Web Scraping auch für Nicht-Vollzeitentwickler zugänglich.

Verschiedene Teams nutzen diese Daten auf unterschiedliche Weise:

Eine Marke für Küchenutensilien , passte die Rezeptur an und holte sich innerhalb von 60 Tagen wieder Platz 1 unter den Bestsellern zurück. Ein Fitness-Tracker-Anbieter , erkannte ein Latexproblem, brachte eine hypoallergene Variante auf den Markt und senkte die Retouren um 40 %. Genau diese Art von ROI macht den technischen Aufwand lohnend.

Login-Sperre: Warum dein Amazon-Review-Scraper nicht mehr funktioniert

Am 14. November 2024 begann Amazon damit, für die vollständige Produkt-Bewertungsseite eine Anmeldung zu verlangen. Die Änderung wurde sowohl in als auch in bestätigt. Wenn du /product-reviews/{ASIN}/ in einem Inkognito-Fenster aufrufst, landest du inzwischen auf einer Login-Seite statt bei den Bewertungen.

Die Symptome sind tückisch: Dein Skript bekommt zwar einen 200 OK-Status, aber im HTML-Body steht ein Login-Formular (name="email", id="ap_password") statt der Rezensionen. Kein Fehlercode. Kein CAPTCHA. Einfach … nichts Brauchbares.

Amazon macht das aus Anti-Bot-Gründen und wegen regionaler Compliance-Anforderungen. Die Durchsetzung ist allerdings nicht immer konsistent – manchmal lädt ein frisches Browserfenster noch ein paar Bewertungen, bevor die Sperre greift, vor allem auf der ersten Seite –, aber für Scraper im größeren Maßstab solltest du davon ausgehen, dass die Sperre immer aktiv ist.

Die verschiedenen Amazon-Länderdomains (.de, .co.uk, .co.jp) setzen diese Sperre unabhängig voneinander durch. Wie es ein Foren-Nutzer formulierte: „Für jedes Land ist ein eigener Login nötig.“ Deine .com-Cookies funktionieren also nicht auf .co.uk.

Featured Reviews vs. vollständige Bewertungen: Was ohne Login noch zugänglich ist

Amazon-Produktseiten (/dp/{ASIN}/) zeigen weiterhin ungefähr ohne Anmeldung an. Diese werden von Amazons Algorithmus ausgewählt und reichen für einen schnellen Stimmungscheck, sind aber weder sortierbar noch filterbar oder über mehrere Seiten verteilt.

Die vollständigen Bewertungsseiten (/product-reviews/{ASIN}/) – mit Sortierung nach Neuheit, Filterung nach Sternebewertung und Pagination über Hunderte von Rezensionen – erfordern einen Login.

Wenn du nur ein paar Bewertungen für einen schnellen Eindruck brauchst, reicht die Produktseite. Für Hunderte oder Tausende musst du die Authentifizierung sauber lösen.

Was du vor dem Start brauchst: Python-Setup und Bibliotheken

Bevor wir Code schreiben, hier das Setup:

• Schwierigkeitsgrad: Mittelstufe (Python-Kenntnisse, grundlegendes HTML-Verständnis)
• Zeitbedarf: ca. 45 Minuten für die komplette Pipeline; ca. 10 Minuten für einen einfachen Scrape
• Benötigt: Python 3.8+, Chrome-Browser, ein gültiges Amazon-Konto

Installiere die Kernbibliotheken:

1pip install requests beautifulsoup4 lxml pandas textblob

Optional (für fortgeschrittene Sentiment-Analyse):

1pip install transformers torch

Was ist eine ASIN? Das ist Amazons 10-stellige Produkt-ID. Du findest sie in jeder Produkt-URL – zum Beispiel ist in amazon.com/dp/B0BCNKKZ91 die ASIN B0BCNKKZ91. Genau diesen Wert brauchst du später für die Bewertungs-URL.

Schritt 1: Mit Cookie-basierter Authentifizierung an der Login-Sperre vorbeikommen

Der zuverlässigste Weg ist: In deinem Browser bei Amazon anmelden, die Session-Cookies kopieren und sie in deine Python-requests.Session() einfügen. So vermeidest du CAPTCHA-Abfragen und SMS-2FA, die bei Selenium-basierten Login-Automationen oft Probleme machen.

Du brauchst diese sieben Cookies:

So extrahierst du Cookies aus Chrome DevTools

1. Melde dich in Chrome bei amazon.com an
2. Öffne die DevTools (F12 oder Rechtsklick → Untersuchen)
3. Gehe zu Application → Storage → Cookies → https://www.amazon.com
4. Suche jeden Cookie-Namen aus der Tabelle und kopiere den jeweiligen Wert
5. Formatiere sie als durch Semikolon getrennte Zeichenkette für Python

So richtest du deine Session ein:

1import requests
2session = requests.Session()
3# Hier deine Cookie-Werte einfügen
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

Wichtig: Verwende für alle Requests dasselbe session-Objekt. So bleiben die Cookies konsistent und das Verhalten ähnelt einer echten Browser-Session. Cookies halten unter Scraping-Last meist Tage bis Wochen, aber wenn du wieder Login-Weiterleitungen bekommst, musst du sie im Browser neu ziehen.

Bei Marktplätzen außerhalb von .com ändern sich die Cookie-Namen leicht – amazon.de verwendet at-acbde statt at-main, amazon.co.uk nutzt at-acbuk usw. Jeder Marktplatz braucht seine eigene unabhängige Session.

Schritt 2: Den Request bauen und Review-HTML mit BeautifulSoup parsen

Die Amazon-Bewertungs-URL folgt diesem Muster:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

Die zentrale Funktion:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # Freundliche Pause
5    response = session.get(url, timeout=15)
6    # Login-Sperre erkennen
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("Login-Sperre erkannt — bitte Cookies erneuern")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

Ein kleiner Trick, der hilft: Bevor du die Bewertungsseite aufrufst, besuche zuerst die Produktseite. Das erzeugt ein natürlicheres Browsing-Muster in deiner Session.

1# Zuerst Produktseite besuchen (wirkt wie normales Browsing)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# Dann die Bewertungsseite aufrufen
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

Schritt 3: Stabile Selektoren nutzen, um Bewertungsdaten zu extrahieren (nicht auf CSS-Klassen setzen)

Hier scheitern die meisten Tutorials von 2022–2023. Amazon verschleiert CSS-Klassennamen – sie ändern sich regelmäßig, und wie ein frustrierter Entwickler in einem Forum schrieb: „Keiner von ihnen hatte ein einziges konsistentes Muster bei den Klassennamen der span-Tags.“

Die Lösung: Amazon verwendet data-hook-Attribute auf den Bewertungs-Elementen, und die sind erstaunlich stabil. Es handelt sich um semantische Kennungen, auf die auch Amazons Frontend-Code angewiesen ist, deshalb werden sie nicht zufällig geändert.

Der Extraktionscode mit data-hook-Selektoren:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # Sternebewertung
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # Titel
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # Text
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # Autor
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # Datum und Land
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # Format: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # Verifizierter Kauf
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

Ich nutze genau diese Selektoren jetzt seit Monaten gegen mehrere ASINs, und die data-hook-Attribute haben sich kein einziges Mal geändert. Die CSS-Klassen dagegen wurden im gleichen Zeitraum mindestens zweimal rotiert.

Schritt 4: Pagination und Amazons 10-Seiten-Limit behandeln

Amazon begrenzt den pageNumber-Parameter auf 10 Seiten mit jeweils 10 Bewertungen – also eine harte Obergrenze von ungefähr 100 Bewertungen pro Filterkombination. Der „Nächste Seite“-Button verschwindet einfach nach Seite 10.

Einfache Pagination-Schleife:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # Keine weiteren Bewertungen auf dieser Seite
8    all_reviews.extend(page_reviews)
9    print(f"Seite {page}: {len(page_reviews)} Bewertungen")

Wie man mehr als 10 Seiten Amazon-Bewertungen bekommt

Der Workaround ist Filter-Bucketing. Jede Kombination aus filterByStar und sortBy bekommt ihr eigenes unabhängiges 10-Seiten-Fenster.

Sternfilter-Werte: one_star, two_star, three_star, four_star, five_star
Sortierwerte: recent, helpful (Standard)

Wenn du alle 5 Sternfilter × 2 Sortierungen kombinierst, kannst du bis zu 100 Seiten bzw. 1.000 Bewertungen pro Produkt erreichen – und bei Produkten mit ungleichmäßiger Sterneverteilung kommst du oft nahe an den vollständigen Review-Satz heran.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # Einfache Duplikaterkennung
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # Duplikate über Titel + Autor erkennen
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Seite {page}: {len(page_reviews)} Bewertungen")
23print(f"Gesamtzahl eindeutiger Bewertungen: {len(all_reviews)}")

Zwischen den Buckets gibt es Überschneidungen, deshalb ist Deduplizierung wichtig. Ich verwende als schnellen Schlüssel eine Kombination aus Bewertungstitel und Autorenname – nicht perfekt, aber damit erwischt man den Großteil der Duplikate.

Schritt 5: Anti-Bot-Schutz austricksen (rotieren, drosseln, wiederholen)

Amazon nutzt AWS WAF Bot Control, und das System ist inzwischen deutlich aggressiver geworden. Einlagige Gegenmaßnahmen (nur User-Agents rotieren, nur Verzögerungen einbauen) reichen längst nicht mehr aus.

Ein produktionsreifer Retry-Wrapper:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # Blocks erkennen
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"CAPTCHA erkannt. Warte {wait}s...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"Rate-Limit ({response.status_code}). Warte {wait}s...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("Login-Sperre — Cookies abgelaufen")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"Versuch {attempt + 1} fehlgeschlagen: {e}")
33    return None

Ein Hinweis zu Proxys: Amazon (AWS, GCP, Azure, DigitalOcean) auf Netzwerkebene. Wenn du mehr als ein paar Hundert Seiten scrape-st, sind Residential Proxies praktisch Pflicht – rechne je nach Volumen mit etwa 50–200+ US-Dollar pro Monat. Für kleinere Projekte (unter 100 Requests pro Tag) funktioniert ein sauber gedrosselter Abruf von deiner Heim-IP oft noch gut.

Amazon prüft außerdem TLS-Fingerprints. Das Standard-requests-Paket in Python hat einen . Für produktive Scraper solltest du curl_cffi in Betracht ziehen, weil es echte Browser-TLS-Stacks imitiert. Für Scraping im Tutorial-Umfang (ein paar Hundert Seiten) reicht requests mit guten Headern meist aus.

Schritt 6: Deine Amazon-Bewertungen als CSV oder Excel exportieren

Sobald du die Bewertungen gesammelt hast, ist der Export in ein nutzbares Format mit pandas ganz einfach:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"{len(df)} Bewertungen nach amazon_reviews.csv exportiert")

Beispielausgabe:

Für den Excel-Export: df.to_excel("amazon_reviews.xlsx", index=False) (dafür ist openpyxl nötig).

Für Google Sheets funktioniert die gspread-Bibliothek, aber sie erfordert – Projekt anlegen, zwei APIs aktivieren, Service-Account-Zugangsdaten erzeugen, Tabellenblatt freigeben. Wenn sich das nach mehr Aufwand anhört als das eigentliche Scraping, liegst du nicht falsch. (Genau an diesem Punkt wirkt ein Tool wie , das mit einem Klick nach Google Sheets exportiert, plötzlich sehr attraktiv.)

Bonus: In 5 Zeilen Python Sentiment-Analyse zu deinen Scraped Reviews hinzufügen

Die meisten Scraping-Tutorials hören beim CSV-Export auf. Aber erst mit Sentiment-Werten werden aus Rohdaten echte Entscheidungen.

Der schnellste Baseline-Ansatz nutzt TextBlob:

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

Damit erhält jede Bewertung einen Polaritätswert von -1.0 (sehr negativ) bis +1.0 (sehr positiv). Beispielausgabe:

Spannend sind vor allem die Ausreißer – etwa eine 3-Sterne-Bewertung mit positivem Text oder eine 5-Sterne-Bewertung mit negativer Sprache. Solche Abweichungen zeigen oft nuancierte Kundenmeinungen, die Sterne allein nicht erfassen.

Für präzisere Ergebnisse in Produktionsqualität empfehlen sich Hugging Face Transformers. , und – deutlich mehr als lexikonbasierte Tools. Das Modell nlptown/bert-base-multilingual-uncased-sentiment kann sogar direkt 1–5 Sterne vorhersagen:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

Amazon-Bewertungen folgen einer – ein großer Peak bei 5 Sternen, ein kleinerer bei 1 Stern und ein Tal in der Mitte. Deshalb ist der Durchschnittswert oft ein schlechter Indikator für die tatsächliche Produktqualität. Analysiere den 1-Stern-Cluster und suche nach wiederkehrenden Themen – dort steckt häufig der eine, behebbare Defekt.

Die ehrliche Abwägung: DIY-Python vs. bezahlte Scraping-APIs vs. Thunderbit

Ich habe Python-Scraper für Amazon selbst gepflegt, und ehrlich gesagt: Sie brechen. Selektoren ändern sich, Cookies laufen ab, Amazon rollt eine neue Bot-Erkennung aus – und plötzlich verbringst du deinen Samstagmorgen mit Debugging statt mit Datenanalyse. Auch in Foren berichten Nutzer dieselbe Frustration: DIY-Skripte, die „letzten Monat noch funktioniert haben“, brauchen heute dauernd Patches.

So schneiden die drei Hauptansätze im Vergleich ab:

Python gibt dir volle Kontrolle und ist der beste Weg, Web Scraping wirklich von Grund auf zu verstehen. Bezahlte APIs (ScrapingBee, Oxylabs, Bright Data) sind sinnvoll für produktive Pipelines, bei denen Verfügbarkeit wichtiger ist als Kosten. Und für Teams, die Bewertungsdaten ohne Entwicklungsaufwand brauchen – etwa E-Commerce-Teams, die wöchentlich Wettbewerbsprodukte überwachen, oder Marketing-Teams, die Kundensprache für Anzeigen suchen –, gibt es einen dritten Weg.

So scrapt man Amazon-Bewertungen mit Thunderbit – ganz ohne Code und Wartung

Wir haben genau für die Fälle entwickelt, in denen sich ein Python-Scraper wie unnötiger Overhead anfühlt. Der Ablauf sieht so aus:

1. Installiere die
2. Öffne die Amazon-Produktbewertungsseite im Browser (du bist bereits eingeloggt, die Login-Sperre ist also kein Thema)
3. Klicke auf „AI Suggest Fields“ – Thunderbit liest die Seite und schlägt Spalten wie Autor, Bewertung, Titel, Bewertungstext, Datum und Verifizierter Kauf vor
4. Klicke auf „Scrape“ – die Daten werden sofort extrahiert, inklusive eingebauter Pagination
5. Exportiere nach Excel, Google Sheets, Airtable oder Notion

Der größte Vorteil: Die AI von Thunderbit liest die Seitenstruktur jedes Mal neu aus. Keine CSS-Selektoren, die gepflegt werden müssen, keine Cookie-Verwaltung, kein Anti-Bot-Code. Wenn Amazon sein HTML ändert, passt sich die AI an. Für Leser, die programmgesteuerten Zugriff ohne kompletten DIY-Aufwand möchten, bietet Thunderbit außerdem eine – strukturierte Datenerfassung per API mit AI-gestützter Felderkennung, ganz ohne Selektorpflege.

Für tiefere Einblicke in Amazon-Daten findest du auch unsere Anleitungen zu und .

Tipps für das Scrapen von Amazon-Bewertungen in großem Umfang mit Python

Wenn du Bewertungen über viele ASINs hinweg scrapen willst, sparen dir diese Praktiken viel Ärger:

• Verarbeite ASINs in Batches mit Pausen zwischen den Produkten, nicht nur zwischen den Seiten. Ich nutze 10–15 Sekunden Pause zwischen ASINs.
• Dedupliziere aggressiv. Wenn du mehrere Sternfilter- und Sortierkombinationen kombinierst, bekommst du Überschneidungen. Verwende (title, author, date)-Tuples als Deduplizierungs-Schlüssel.
• Protokolliere Fehler. Halte fest, welche ASIN-, Seiten- und Filterkombinationen fehlgeschlagen sind, damit du nur diese erneut scrapen musst.
• Nutze für größere Projekte eine Datenbank. Eine einfache SQLite-Datenbank skaliert deutlich besser als immer größer werdende CSV-Dateien:

1import sqlite3
2conn = sqlite3.connect("reviews.db")
3df.to_sql("reviews", conn, if_exists="append", index=False)

• Plane wiederkehrende Scrapes. Für laufendes Monitoring kannst du einen Cronjob einrichten oder Thundebits Scheduled-Scraper-Funktion nutzen – URL und Zeitplan angeben, den Rest erledigt das Tool ohne Server.

Weitere Ansätze findest du in unseren Beiträgen zu und .

Ein kurzer Hinweis zu rechtlichen und ethischen Aspekten

Amazons verbieten ausdrücklich „den Einsatz von Robotern, Spider, Scraper oder anderen automatisierten Mitteln, um auf Amazon Services zuzugreifen“. Gleichzeitig ist die aktuelle US-Rechtsprechung bei öffentlich zugänglichen Daten eher scraperfreundlich. In entschied ein Bundesgericht, dass das Scrapen öffentlich zugänglicher Daten nicht gegen die Nutzungsbedingungen verstößt, wenn der Scraper kein eingeloggter „User“ ist.

Die Feinheit: Scraping hinter einem Login – also genau das, was dieses Tutorial behandelt – bewegt sich im Vertragsrecht, weil du beim Erstellen des Kontos Amazons AGB akzeptiert hast. Öffentlich sichtbare Featured Reviews zu scrapen ist rechtlich weniger riskant als Scraping hinter der Login-Sperre.

Praktische Regeln: Veröffentliche Scraped Daten nicht kommerziell weiter, sammle keine personenbezogenen Daten über das öffentlich Sichtbare hinaus, respektiere robots.txt und hole bei großen oder kommerziellen Vorhaben juristischen Rat ein. Das ist keine Rechtsberatung. Mehr zum Thema findest du in unserem Überblick über .

Fazit: Amazon-Bewertungen mit Python scrapen – oder den Code ganz weglassen

Kurze Zusammenfassung dessen, was dieser Leitfaden gezeigt hat:

• Die Login-Sperre ist real, aber mit Cookie-basierter Authentifizierung lösbar – kopiere 7 Cookies aus deinem Browser und injiziere sie in eine requests.Session()
• Verwende data-hook-Selektoren statt CSS-Klassen, damit dein Scraper nicht alle paar Wochen kaputtgeht
• Kombiniere Sternfilter und Sortierungen, um das 10-Seiten-Limit zu umgehen und mehr als 500 Bewertungen pro Produkt zu erreichen
• Ergänze Sentiment-Analyse mit TextBlob für einen schnellen Baseline-Wert oder Hugging Face Transformers für produktionsreife Genauigkeit
• Pflege Anti-Bot-Maßnahmen: Drosselung, Rotation der User-Agents, Exponential Backoff und Residential Proxies bei größerem Umfang

Python gibt dir volle Kontrolle und ist der beste Weg, zu verstehen, was unter der Haube passiert. Aber wenn dein Anwendungsfall eher lautet: „Ich brauche bis Freitag Wettbewerbsbewertungen in einer Tabelle“ statt „Ich will eine Produktions-Datenpipeline bauen“, dann ist der Wartungsaufwand eines eigenen Scrapers vielleicht einfach zu hoch.

erledigt Authentifizierung, Selektoren, Pagination und Export mit wenigen Klicks – probiere den aus und schau, ob es zu deinem Workflow passt. Während Amazon seine Anti-Bot-Maßnahmen weiter verschärft, werden KI-gestützte Tools, die sich in Echtzeit anpassen, immer weniger ein Nice-to-have und immer mehr eine Notwendigkeit.

Du kannst dir auch unseren ansehen, dort findest du Video-Tutorials zu Scraping-Workflows.

FAQs

1. Kann man Amazon-Bewertungen ohne Login scrapen?

Ja, aber nur die etwa 8 „Featured Reviews“, die auf der Produktdetailseite (/dp/{ASIN}/) angezeigt werden. Die vollständigen Bewertungsseiten mit Sortierung, Filtern und Pagination erfordern seit Ende 2024 eine Anmeldung. Für die meisten Business-Anwendungsfälle musst du die Login-Sperre also umgehen.

2. Ist es legal, Amazon-Bewertungen zu scrapen?

Amazons Nutzungsbedingungen verbieten automatisiertes Scraping. Allerdings stützt die jüngere US-Rechtsprechung (Meta v. Bright Data, 2024; hiQ v. LinkedIn) das Scrapen öffentlich zugänglicher Daten. Scraping hinter einem Login ist rechtlich riskanter, weil du Amazons AGB bereits zugestimmt hast. Für kommerzielle Nutzung solltest du rechtlichen Rat einholen.

3. Wie viele Amazon-Bewertungen kann ich pro Produkt scrapen?

Amazon begrenzt die Bewertungsseiten auf 10 pro Sortier- und Sternfilter-Kombination. Wenn du alle 5 Sternfilter × 2 Sortierungen nutzt, kannst du bis zu 100 Seiten bzw. rund 1.000 Bewertungen pro Produkt erreichen. Mit Keyword-Filtern ist die theoretische Obergrenze deutlich höher, allerdings mit erheblicher Duplikatmenge.

4. Welche Python-Bibliothek ist am besten für Amazon Review Scraping?

requests + BeautifulSoup für statisches HTML ist die häufigste und zuverlässigste Kombination. Selenium ist hilfreich, wenn JavaScript-Rendering nötig ist. Als No-Code-Alternative, die Login-Sperren und Pagination automatisch handhabt, probiere .

5. Wie verhindere ich Blockierungen beim Scrapen von Amazon?

Rotiere User-Agent-Strings aus einem Pool von 10+ echten Browser-Strings, füge zufällige Pausen von 2–5 Sekunden zwischen Requests ein, implementiere Exponential Backoff bei 503/429-Fehlern, verwende für größeren Umfang Residential Proxies (Rechenzentrums-IPs werden oft direkt blockiert) und halte die Session-Cookies über alle Requests hinweg konsistent. Für einen wartungsfreien Ansatz übernimmt Thunderbit den Anti-Bot-Schutz automatisch über deine Browser-Session.

Mehr erfahren