Sechs Wochen lang lief mein Amazon-Bewertungs-Scraper wie geschmiert – und dann kam eines Morgens zwar weiterhin 200 OK zurück, aber die Seite war leer. Kein Fehler, kein CAPTCHA, nur nacktes HTML ohne einen einzigen Inhalt, wo vorher Hunderte Rezensionen standen.
Klingt vertraut? Dann sitzt du im selben Boot wie viele andere. Ende 2025 hat Amazon seine vollständigen Bewertungsseiten hinter eine Login-Sperre verlegt und damit über Nacht unzählige Python-Skripte lahmgelegt. Ich habe die letzten Monate bei Thunderbit von beiden Seiten an diesem Problem gesessen – wir bauen unseren AI Scraper, und parallel betreibe ich meine eigene Python-Pipeline für Bewertungen. Genau deshalb wollte ich den Leitfaden schreiben, den ich selbst gebraucht hätte, als mein Skript plötzlich ins Leere lief. Hier zeige ich den Ansatz, der tatsächlich trägt: Cookie-basierte Authentifizierung, stabile Selektoren, die Amazons CSS-Verschleierung überstehen, Workarounds fürs 10-Seiten-Limit, Anti-Bot-Maßnahmen und als Bonus einen Teil zur Sentiment-Analyse, der rohe Rezensionen in echte Business-Insights übersetzt. Und falls du zwischendurch denkst „eigentlich will ich diesen ganzen Code gar nicht warten“, zeige ich dir auch, wie Thunderbit dieselbe Aufgabe in etwa zwei Minuten ganz ohne Python erledigt.
Was ist Amazon Review Scraping – und warum ist es wichtig?
Amazon Review Scraping meint das programmatische Auslesen von Kundenbewertungen – Sternebewertungen, Bewertungstext, Autorennamen, Datum, Hinweise auf verifizierte Käufe und mehr – direkt von Amazon-Produktseiten. Da Amazon die Bewertungsinhalte bereits 2010 aus seiner Product Advertising API entfernt hat und nie wieder zurückgeholt hat, bleibt Web Scraping der einzige programmatische Weg zu diesen Daten.
Die Zahlen sind eindeutig. 95 % der Käufer lesen vor dem Kauf Bewertungen, und 94 % nennen Amazon als ihre wichtigste Quelle für Produktbewertungen. Schon 5 Bewertungen auf einer Produktseite können die Conversion um 270 % steigern. Unternehmen, die Bewertungsstimmungen systematisch auswerten, verzeichnen bis zu 15 % höhere Kundenbindung. Das ist keine abstrakte Data-Science-Spielerei – das sind Wettbewerbsinformationen, Signale für Produktverbesserungen und Marketing-Sprache, im Klartext direkt auf Amazons Servern.
Warum Amazon-Bewertungen mit Python scrapen?
Für diese Aufgabe bleibt Python die erste Wahl. Es ist die am meisten gewünschte Sprache im Stack Overflow Developer Survey 2024, und das Ökosystem rund um requests, BeautifulSoup, pandas und Scrapy öffnet Web Scraping auch für alle, die nicht hauptberuflich entwickeln.
Verschiedene Teams setzen diese Daten unterschiedlich ein:
| Team | Anwendungsfall | Welche Daten sie extrahieren |
|---|---|---|
| Produkt / F&E | Wiederkehrende Beschwerden erkennen, Prioritäten setzen | 1–2-Sterne-Bewertungen, Keyword-Häufigkeiten |
| Sales | Stimmungsbild zu Wettbewerbsprodukten beobachten | Bewertungen, Trends im Bewertungsvolumen |
| Marketing | Formulierungen von Kunden für Anzeigen nutzen | Positive Bewertungsaussagen, Feature-Erwähnungen |
| E-Commerce Ops | Eigene Produktstimmung über Zeit verfolgen | Sterneverteilung, Anteil verifizierter Käufe |
| Marktforschung | Kategorien führender Produkte vergleichen | Review-Datasets über mehrere ASINs |
Eine Marke für Küchenutensilien wertete negative Bewertungen aus, stellte fest, dass 22 % „die Antihaftbeschichtung nutzt sich ab“ erwähnten, passte die Rezeptur an und holte sich innerhalb von 60 Tagen wieder Platz 1 unter den Bestsellern zurück. Ein Fitness-Tracker-Anbieter identifizierte „Reizungen durch das Armband“ in Rezensionen, erkannte ein Latexproblem, brachte eine hypoallergene Variante auf den Markt und drückte die Retouren um 40 %. Genau diese Art von ROI rechtfertigt den technischen Aufwand.
Login-Sperre: Warum dein Amazon-Review-Scraper nicht mehr funktioniert
Am 14. November 2024 begann Amazon, für die vollständige Produkt-Bewertungsseite eine Anmeldung zu verlangen. Bestätigt wurde die Änderung sowohl in Community-Foren als auch in Blogs von Scraping-Anbietern. Rufst du /product-reviews/{ASIN}/ in einem Inkognito-Fenster auf, landest du inzwischen auf einer Login-Seite statt bei den Bewertungen.
Die Symptome sind heimtü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 Verwertbares.
Amazon zieht diese Linie aus Anti-Bot-Gründen und wegen regionaler Compliance-Anforderungen. Die Durchsetzung ist allerdings nicht immer einheitlich – manchmal lädt ein frisches Browserfenster noch ein paar Bewertungen, bevor die Sperre greift, vor allem auf der ersten Seite. Bei Scrapern im größeren Maßstab solltest du aber davon ausgehen, dass die Sperre durchgehend aktiv ist.
Die verschiedenen Amazon-Länderdomains (.de, .co.uk, .co.jp) setzen diese Sperre jeweils eigenständig durch. Ein Foren-Nutzer brachte es auf den Punkt: „Für jedes Land ist ein eigener Login nötig.“ Deine .com-Cookies greifen 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 8 „Featured Reviews“ ohne Anmeldung an. Die wählt Amazons Algorithmus aus, und für einen schnellen Stimmungscheck reichen sie – sortieren, filtern oder über mehrere Seiten blättern kannst du sie jedoch nicht.
Die vollständigen Bewertungsseiten (/product-reviews/{ASIN}/) – mit Sortierung nach Neuheit, Filterung nach Sternebewertung und Pagination über Hunderte Rezensionen – setzen einen Login voraus.
Brauchst du nur ein paar Bewertungen für einen schnellen Eindruck, reicht die Produktseite. Geht es um 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:
pip install requests beautifulsoup4 lxml pandas textblob
Optional (für fortgeschrittene Sentiment-Analyse):
pip install transformers torch
Was ist eine ASIN? Das ist Amazons 10-stellige Produkt-ID. Du findest sie in jeder Produkt-URL – in amazon.com/dp/B0BCNKKZ91 ist die ASIN etwa B0BCNKKZ91. Genau diesen Wert brauchst du später für die Bewertungs-URL.
Schritt 1: Mit Cookie-basierter Authentifizierung an der Login-Sperre vorbeikommen
Am verlässlichsten klappt das so: in deinem Browser bei Amazon anmelden, die Session-Cookies kopieren und sie in deine Python-requests.Session() übernehmen. Damit umgehst du CAPTCHA-Abfragen und SMS-2FA, die bei Selenium-basierten Login-Automationen oft Ärger machen.
Du brauchst diese sieben Cookies:
| Cookie-Name | Zweck |
|---|---|
session-id | Rotierende Session-ID |
session-id-time | Zeitstempel der Session |
session-token | Rotierendes Session-Token |
ubid-main | Browser-Identifikator des Nutzers |
at-main | Primäres Auth-Token |
sess-at-main | Authentifizierung innerhalb der Session |
x-main | E-Mail-gebundener Nutzer-Identifikator |
So extrahierst du Cookies aus Chrome DevTools
- Melde dich in Chrome bei amazon.com an
- Öffne die DevTools (F12 oder Rechtsklick → Untersuchen)
- Gehe zu Application → Storage → Cookies →
https://www.amazon.com - Suche jeden Cookie-Namen aus der Tabelle und kopiere den jeweiligen Wert
- Formatiere sie als durch Semikolon getrennte Zeichenkette für Python
So richtest du deine Session ein:
import requests
session = requests.Session()
# Hier deine Cookie-Werte einfügen
cookies = {
"session-id": "YOUR_SESSION_ID",
"session-id-time": "YOUR_SESSION_ID_TIME",
"session-token": "YOUR_SESSION_TOKEN",
"ubid-main": "YOUR_UBID_MAIN",
"at-main": "YOUR_AT_MAIN",
"sess-at-main": "YOUR_SESS_AT_MAIN",
"x-main": "YOUR_X_MAIN",
}
headers = {
"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",
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.5",
}
session.cookies.update(cookies)
session.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, doch sobald wieder Login-Weiterleitungen auftauchen, musst du sie im Browser neu ziehen.
Bei Marktplätzen außerhalb von .com ändern sich die Cookie-Namen leicht – amazon.de nutzt at-acbde statt at-main, amazon.co.uk verwendet 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:
https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1
Die zentrale Funktion:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Freundliche Pause
response = session.get(url, timeout=15)
# Login-Sperre erkennen
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Login-Sperre erkannt — bitte Cookies erneuern")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Ein kleiner Kniff, der hilft: Bevor du die Bewertungsseite aufrufst, besuch zuerst die Produktseite. Das erzeugt ein natürlicheres Browsing-Muster in deiner Session.
# Zuerst Produktseite besuchen (wirkt wie normales Browsing)
product_url = f"https://www.amazon.com/dp/{asin}"
session.get(product_url, timeout=15)
time.sleep(random.uniform(1, 3))
# Dann die Bewertungsseite aufrufen
reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
soup = get_soup(session, reviews_url)
Schritt 3: Stabile Selektoren nutzen, um Bewertungsdaten zu extrahieren (nicht auf CSS-Klassen setzen)
Genau hier scheitern die meisten Tutorials von 2022–2023. Amazon verschleiert seine CSS-Klassennamen – sie wechseln 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.“
Der Ausweg: Amazon vergibt auf den Bewertungs-Elementen data-hook-Attribute, und die sind erstaunlich stabil. Es sind semantische Kennungen, auf die auch Amazons Frontend-Code angewiesen ist, deshalb werden sie nicht willkürlich verändert.
| Bewertungsfeld | Stabiler Selektor (data-hook) | Anfälliger Selektor (class) |
|---|---|---|
| Bewertungstext | [data-hook="review-body"] | .review-text-content (ändert sich) |
| Sternebewertung | [data-hook="review-star-rating"] | .a-icon-alt (mehrdeutig) |
| Titel der Bewertung | [data-hook="review-title"] | .review-title (manchmal) |
| Autorenname | span.a-profile-name | Relativ stabil |
| Bewertungsdatum | [data-hook="review-date"] | .review-date (regionsabhängig) |
| Verifizierter Kauf | [data-hook="avp-badge"] | span.a-size-mini |
Der Extraktionscode mit data-hook-Selektoren:
import re
def extract_reviews(soup):
reviews = []
review_divs = soup.select('[data-hook="review"]')
for div in review_divs:
# Sternebewertung
rating_el = div.select_one('[data-hook="review-star-rating"]')
rating = None
if rating_el:
rating_text = rating_el.get_text(strip=True)
match = re.search(r'(\d\.?\d?)', rating_text)
if match:
rating = float(match.group(1))
# Titel
title_el = div.select_one('[data-hook="review-title"]')
title = title_el.get_text(strip=True) if title_el else ""
# Text
body_el = div.select_one('[data-hook="review-body"]')
body = body_el.get_text(strip=True) if body_el else ""
# Autor
author_el = div.select_one('span.a-profile-name')
author = author_el.get_text(strip=True) if author_el else ""
# Datum und Land
date_el = div.select_one('[data-hook="review-date"]')
date_text = date_el.get_text(strip=True) if date_el else ""
# Format: "Reviewed in the United States on January 15, 2025"
country_match = re.search(r'Reviewed in (.+?) on', date_text)
date_match = re.search(r'on (.+)$', date_text)
country = country_match.group(1) if country_match else ""
date = date_match.group(1) if date_match else ""
# Verifizierter Kauf
verified_el = div.select_one('[data-hook="avp-badge"]')
verified = bool(verified_el)
reviews.append({
"author": author,
"rating": rating,
"title": title,
"content": body,
"date": date,
"country": country,
"verified": verified,
})
return reviews
Ich setze genau diese Selektoren jetzt seit Monaten gegen mehrere ASINs ein, und die data-hook-Attribute haben sich kein einziges Mal verändert. Die CSS-Klassen dagegen sind im selben Zeitraum mindestens zweimal durchrotiert worden.
Schritt 4: Pagination und Amazons 10-Seiten-Limit behandeln
Amazon deckelt den pageNumber-Parameter bei 10 Seiten mit jeweils 10 Bewertungen – also eine harte Obergrenze von rund 100 Bewertungen pro Filterkombination. Der „Nächste Seite“-Button verschwindet nach Seite 10 schlicht.
Einfache Pagination-Schleife:
all_reviews = []
for page in range(1, 11):
url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break # Keine weiteren Bewertungen auf dieser Seite
all_reviews.extend(page_reviews)
print(f"Seite {page}: {len(page_reviews)} Bewertungen")
Wie man mehr als 10 Seiten Amazon-Bewertungen bekommt
Der Workaround heißt 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)
Kombinierst du alle 5 Sternfilter × 2 Sortierungen, kommst du auf bis zu 100 Seiten bzw. 1.000 Bewertungen pro Produkt – und bei Produkten mit ungleichmäßiger Sterneverteilung näherst du dich damit oft dem vollständigen Review-Satz.
star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
sort_orders = ["recent", "helpful"]
all_reviews = []
seen_titles = set() # Einfache Duplikaterkennung
for star in star_filters:
for sort in sort_orders:
for page in range(1, 11):
url = (
f"https://www.amazon.com/product-reviews/{asin}"
f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
)
soup = get_soup(session, url)
page_reviews = extract_reviews(soup)
if not page_reviews:
break
for review in page_reviews:
# Duplikate über Titel + Autor erkennen
key = (review["title"], review["author"])
if key not in seen_titles:
seen_titles.add(key)
all_reviews.append(review)
print(f"[{star}/{sort}] Seite {page}: {len(page_reviews)} Bewertungen")
print(f"Gesamtzahl eindeutiger Bewertungen: {len(all_reviews)}")
Zwischen den Buckets gibt es Überschneidungen, deshalb ist Deduplizierung wichtig. Als schnellen Schlüssel nehme ich eine Kombination aus Bewertungstitel und Autorenname – nicht perfekt, aber damit fängt man den Großteil der Duplikate ab.
Schritt 5: Anti-Bot-Schutz austricksen (rotieren, drosseln, wiederholen)
Amazon setzt auf AWS WAF Bot Control, und das System ist inzwischen merklich aggressiver geworden. Einlagige Gegenmaßnahmen (nur User-Agents rotieren, nur Verzögerungen einbauen) reichen längst nicht mehr.
| Technik | Umsetzung |
|---|---|
| User-Agents rotieren | Zufällige Auswahl aus 10+ echten Browser-Strings |
| Exponential Backoff | Retry-Verzögerungen von 2s → 4s → 8s bei 503-Fehlern |
| Request-Drosselung | random.uniform(2, 5) Sekunden zwischen Seiten |
| Proxy-Rotation | Wechsel zwischen Residential Proxies |
| Session-Fingerprint | Konsistente Cookies + Header pro Session |
| TLS-Impersonation | Für Produktion curl_cffi statt Standard-requests verwenden |
Ein produktionsreifer Retry-Wrapper:
import time, random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
"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",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
"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",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
]
def scrape_with_retries(session, url, max_retries=3):
for attempt in range(max_retries):
try:
session.headers["User-Agent"] = random.choice(USER_AGENTS)
time.sleep(random.uniform(2, 5))
response = session.get(url, timeout=15)
# Blocks erkennen
if "validateCaptcha" in response.url or "Robot Check" in response.text:
wait = (2 ** attempt) * 5
print(f"CAPTCHA erkannt. Warte {wait}s...")
time.sleep(wait)
continue
if response.status_code in (429, 503):
wait = (2 ** attempt) * 2
print(f"Rate-Limit ({response.status_code}). Warte {wait}s...")
time.sleep(wait)
continue
if "ap_email" in response.text:
raise Exception("Login-Sperre — Cookies abgelaufen")
return BeautifulSoup(response.text, "lxml")
except Exception as e:
if attempt == max_retries - 1:
raise
print(f"Versuch {attempt + 1} fehlgeschlagen: {e}")
return None
Noch ein Hinweis zu Proxys: Amazon sperrt bekannte Rechenzentrums-IP-Bereiche (AWS, GCP, Azure, DigitalOcean) auf Netzwerkebene. Scrapst du mehr als ein paar Hundert Seiten, 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) reicht ein sauber gedrosselter Abruf von deiner Heim-IP oft noch aus.
Amazon prüft außerdem TLS-Fingerprints. Das Standard-requests-Paket in Python hat einen bekannten JA3-Hash, den WAFs oft vorab blockieren. Für produktive Scraper lohnt sich curl_cffi, weil es echte Browser-TLS-Stacks nachbildet. Im Tutorial-Umfang (ein paar Hundert Seiten) genügt requests mit guten Headern meist.
Schritt 6: Deine Amazon-Bewertungen als CSV oder Excel exportieren
Sobald die Bewertungen gesammelt sind, geht der Export in ein nutzbares Format mit pandas mühelos:
import pandas as pd
df = pd.DataFrame(all_reviews)
df.to_csv("amazon_reviews.csv", index=False)
print(f"{len(df)} Bewertungen nach amazon_reviews.csv exportiert")
Beispielausgabe:
| author | rating | title | content | date | country | verified |
|---|---|---|---|---|---|---|
| Sarah M. | 5.0 | Bester Kauf dieses Jahres | Der Akku hält den ganzen Tag, das Display ist wunderschön... | January 15, 2025 | the United States | True |
| Mike T. | 2.0 | Nach 2 Wochen enttäuscht | Der Ladeanschluss hat aufgehört zu funktionieren... | February 3, 2025 | the United States | True |
| Priya K. | 4.0 | Starkes Preis-Leistungs-Verhältnis | Macht alles, was ich brauche, nur leichte Verzögerungen bei schweren Apps... | March 10, 2025 | the United States | False |
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, doch sie verlangt mehr als 8 Schritte Google-Cloud-Konfiguration – Projekt anlegen, zwei APIs aktivieren, Service-Account-Zugangsdaten erzeugen, Tabellenblatt freigeben. Falls dir das nach mehr Aufwand klingt als das eigentliche Scraping, liegst du nicht daneben. (Genau hier wirkt ein Tool wie Thunderbit, das mit einem Klick nach Google Sheets exportiert, plötzlich sehr verlockend.)
Bonus: In 5 Zeilen Python Sentiment-Analyse zu deinen Scraped Reviews hinzufügen
Die meisten Scraping-Tutorials hören beim CSV-Export auf. Doch erst mit Sentiment-Werten werden aus Rohdaten echte Entscheidungen.
Der schnellste Baseline-Ansatz nutzt TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Damit bekommt jede Bewertung einen Polaritätswert von -1.0 (sehr negativ) bis +1.0 (sehr positiv). Beispielausgabe:
| content (gekürzt) | rating | sentiment |
|---|---|---|
| "Battery lasts all day, screen is gorgeous..." | 5.0 | 0.65 |
| "The charging port stopped working after..." | 2.0 | -0.40 |
| "Does everything I need, minor lag on..." | 4.0 | 0.25 |
| "Absolute garbage. Returned immediately." | 1.0 | -0.75 |
| "It's okay. Nothing special but works." | 3.0 | 0.10 |
Am spannendsten sind die Ausreißer – etwa eine 3-Sterne-Bewertung mit positivem Text oder eine 5-Sterne-Bewertung mit negativer Sprache. Solche Abweichungen verraten oft nuancierte Kundenmeinungen, die Sterne allein nicht abbilden.
Für präzisere Ergebnisse in Produktionsqualität empfehlen sich Hugging Face Transformers. VADER wurde auf Tweets trainiert, nicht auf Produktbewertungen, und Transformer-Modelle erreichen über 98 % Genauigkeit bei der Review-Klassifikation – deutlich mehr als lexikonbasierte Tools. Das Modell nlptown/bert-base-multilingual-uncased-sentiment kann sogar direkt 1–5 Sterne vorhersagen:
from transformers import pipeline
clf = pipeline("sentiment-analysis",
model="nlptown/bert-base-multilingual-uncased-sentiment")
df["predicted_stars"] = df["content"].apply(
lambda x: int(clf(str(x)[:512])[0]["label"][0])
)
Amazon-Bewertungen folgen einer J-förmigen Verteilung – ein großer Peak bei 5 Sternen, ein kleinerer bei 1 Stern und ein Tal in der Mitte. Deshalb ist der Durchschnittswert oft ein schwacher Indikator für die tatsächliche Produktqualität. Schau dir den 1-Stern-Cluster genauer an und such 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 gehen kaputt. Selektoren wandern, Cookies laufen ab, Amazon rollt eine neue Bot-Erkennung aus – und schon verbringst du deinen Samstagmorgen mit Debugging statt mit Datenanalyse. Auch in Foren liest man dieselbe Frustration: DIY-Skripte, die „letzten Monat noch liefen“, brauchen heute laufend Patches.
So schneiden die drei Hauptansätze im Vergleich ab:
| Kriterium | DIY Python (BS4/Selenium) | Bezahlte Scraping-API | Thunderbit (No-Code) |
|---|---|---|---|
| Einrichtungszeit | 1–3 Stunden | 30 Min. (API-Key) | 2 Minuten |
| Kosten | Kostenlos (+ Proxy-Kosten) | 50–200+ $/Monat | Kostenloser Tarif verfügbar |
| Umgang mit Login-Sperren | Manuelle Cookie-Verwaltung | Meist abgedeckt | Automatisch abgedeckt |
| Wartung | Hoch (Selektoren brechen) | Niedrig (Anbieter wartet) | Keine (AI passt sich an) |
| Pagination | Eigener Code nötig | Integriert | Integriert |
| Multi-Länder-Support | Separate Sessions pro Domain | Meist unterstützt | Browser-basiert = deine Locale |
| Sentiment-Analyse | Eigener Code nötig | Teilweise enthalten | Nach Google Sheets exportieren und beliebig analysieren |
| Am besten für | Lernen, volle Kontrolle | Skalierung, Produktions-Pipelines | Schnelle Exporte, Nicht-Entwickler-Teams |
Python gibt dir volle Kontrolle und ist der beste Weg, Web Scraping wirklich von Grund auf zu durchdringen. Bezahlte APIs (ScrapingBee, Oxylabs, Bright Data) lohnen sich für produktive Pipelines, bei denen Verfügbarkeit schwerer wiegt als Kosten. Und für Teams, die Bewertungsdaten ohne Entwicklungsaufwand brauchen – etwa E-Commerce-Teams, die wöchentlich Wettbewerbsprodukte überwachen, oder Marketing-Teams auf der Suche nach Kundensprache für Anzeigen – gibt es einen dritten Weg.
So scrapt man Amazon-Bewertungen mit Thunderbit – ganz ohne Code und Wartung
Wir haben Thunderbit genau für die Fälle gebaut, in denen sich ein Python-Scraper wie unnötiger Ballast anfühlt. Der Ablauf sieht so aus:
- Installiere die Thunderbit Chrome Extension
- Öffne die Amazon-Produktbewertungsseite im Browser (du bist bereits eingeloggt, die Login-Sperre ist also kein Thema)
- Klicke auf „AI Suggest Fields“ – Thunderbit liest die Seite und schlägt Spalten wie Autor, Bewertung, Titel, Bewertungstext, Datum und Verifizierter Kauf vor
- Klicke auf „Scrape“ – die Daten werden sofort extrahiert, inklusive eingebauter Pagination
- Exportiere nach Excel, Google Sheets, Airtable oder Notion
Der größte Pluspunkt: Die AI von Thunderbit liest die Seitenstruktur jedes Mal neu ein. Keine CSS-Selektoren, die du pflegen müsstest, keine Cookie-Verwaltung, kein Anti-Bot-Code. Ändert Amazon sein HTML, stellt sich die AI darauf ein. Für Leser, die programmgesteuerten Zugriff ohne kompletten DIY-Aufwand möchten, bietet Thunderbit zusätzlich eine Extract API – 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 Amazon-Produkte und Bewertungen scrapen und Amazon-Verkaufsdaten extrahieren und analysieren.
Tipps für das Scrapen von Amazon-Bewertungen in großem Umfang mit Python
Willst du Bewertungen über viele ASINs hinweg scrapen, ersparen dir diese Praktiken viel Ärger:
- Verarbeite ASINs in Batches mit Pausen zwischen den Produkten, nicht nur zwischen den Seiten. Ich lege 10–15 Sekunden Pause zwischen ASINs ein.
- Dedupliziere aggressiv. Kombinierst du mehrere Sternfilter- und Sortierkombinationen, bekommst du Überschneidungen. Nimm
(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 weiter wachsende CSV-Dateien:
import sqlite3
conn = sqlite3.connect("reviews.db")
df.to_sql("reviews", conn, if_exists="append", index=False)
- Plane wiederkehrende Scrapes. Fürs laufende 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 besten automatisierten Web-Scraping-Tools und Daten von Websites nach Excel scrapen.
Ein kurzer Hinweis zu rechtlichen und ethischen Aspekten
Amazons Nutzungsbedingungen verbieten ausdrücklich „den Einsatz von Robotern, Spider, Scraper oder anderen automatisierten Mitteln, um auf Amazon Services zuzugreifen“. Zugleich ist die aktuelle US-Rechtsprechung bei öffentlich zugänglichen Daten eher scraperfreundlich. In Meta Platforms v. Bright Data (Januar 2024) entschied ein Bundesgericht, dass das Scrapen öffentlich zugänglicher Daten nicht gegen die Nutzungsbedingungen verstößt, solange der Scraper kein eingeloggter „User“ ist.
Der feine Unterschied: Scraping hinter einem Login – also genau das, worum es in diesem Tutorial geht – bewegt sich im Vertragsrecht, weil du beim Anlegen des Kontos Amazons AGB akzeptiert hast. Öffentlich sichtbare Featured Reviews zu scrapen ist rechtlich weniger riskant als Scraping hinter der Login-Sperre. Wer aus dem DACH-Raum personenbezogene Daten verarbeitet, sollte zudem die DSGVO im Blick behalten.
Praktische Regeln: Veröffentliche Scraped Daten nicht kommerziell weiter, sammle keine personenbezogenen Daten über das öffentlich Sichtbare hinaus, respektiere robots.txt und hol dir bei großen oder kommerziellen Vorhaben juristischen Rat. Das ist keine Rechtsberatung. Mehr zum Thema findest du in unserem Überblick über rechtliche Implikationen von Web Scraping.
Fazit: Amazon-Bewertungen mit Python scrapen – oder den Code ganz weglassen
Kurz zusammengefasst, 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 auseinanderfällt - 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 „Ich brauche bis Freitag Wettbewerbsbewertungen in einer Tabelle“ lautet als „Ich will eine Produktions-Datenpipeline bauen“, ist der Wartungsaufwand eines eigenen Scrapers womöglich schlicht zu hoch.
Thunderbit übernimmt Authentifizierung, Selektoren, Pagination und Export mit wenigen Klicks – probier den kostenlosen Tarif aus und schau, ob er zu deinem Workflow passt. Während Amazon seine Anti-Bot-Maßnahmen weiter hochschraubt, werden KI-gestützte Tools, die sich in Echtzeit anpassen, immer weniger zum Nice-to-have und immer mehr zur Notwendigkeit.
Du kannst dir auch unseren Thunderbit YouTube-Kanal 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}/) erscheinen. Die vollständigen Bewertungsseiten mit Sortierung, Filtern und Pagination setzen seit Ende 2024 eine Anmeldung voraus. 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. Die jüngere US-Rechtsprechung (Meta v. Bright Data, 2024; hiQ v. LinkedIn) stützt allerdings 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 deckelt die Bewertungsseiten bei 10 pro Sortier- und Sternfilter-Kombination. Nutzt du alle 5 Sternfilter × 2 Sortierungen, kommst du auf bis zu 100 Seiten bzw. rund 1.000 Bewertungen pro Produkt. Mit Keyword-Filtern liegt 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 hilft, wenn JavaScript-Rendering nötig ist. Als No-Code-Alternative, die Login-Sperren und Pagination automatisch übernimmt, probiere Thunderbit.
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
