Mein Amazon-Bewertungs-Scraper lief sechs Wochen lang ohne Probleme — bis er eines Morgens zwar 200 OK zurückgab, aber nur noch eine leere Seite. Kein Fehler, kein CAPTCHA, einfach nur leeres HTML genau dort, wo vorher Hunderte von Rezensionen standen.
Falls dir das bekannt vorkommt: Du bist nicht allein. Ende 2025 hat Amazon damit begonnen, seine kompletten Bewertungsseiten hinter eine Login-Schranke zu setzen, und unzählige Python-Skripte sind über Nacht kaputtgegangen. Ich habe in den letzten Monaten bei Thunderbit an diesem Problem von beiden Seiten gearbeitet — wir bauen unseren AI Scraper, und ich pflege gleichzeitig meine eigene Python-Pipeline für Bewertungen — deshalb wollte ich endlich den Leitfaden schreiben, den ich mir gewünscht hätte, als mein Skript zum ersten Mal nicht mehr funktionierte. Dieser Beitrag zeigt den Ansatz, der wirklich funktioniert: Cookie-basierte Authentifizierung, stabile Selektoren trotz Amazons CSS-Verschleierung, Workarounds für das 10-Seiten-Limit, Anti-Bot-Schutz und ein Bonus-Abschnitt zur Sentimentanalyse, der rohe Rezensionstexte in echte Business-Erkenntnisse verwandelt. Und falls du nach der Hälfte denkst: „Ehrlich gesagt habe ich keine Lust, diesen ganzen Code zu 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 bedeutet, Kundenbewertungen und dazugehörige Daten automatisiert aus Amazon-Produktseiten zu extrahieren — also Sternebewertungen, Rezensionstexte, Autorennamen, Daten, Verifizierungs-Badges und mehr. Seit Amazon die Bewertungsinhalte 2010 aus der Product Advertising API entfernt hat (und nie wieder zurückgebracht hat), ist Web Scraping der einzige programmatische Weg zu diesen Daten.
Die Zahlen sprechen für sich. 95 % der Käufer lesen vor dem Kauf Bewertungen, und 94 % nennen Amazon als ihre wichtigste Quelle für Produktbewertungen. Schon 5 angezeigte Rezensionen auf einer Produktseite können die Conversion um 270 % steigern. Unternehmen, die Bewertungen systematisch auf Sentiment analysieren, erreichen bis zu 15 % höhere Kundenbindung. Das ist keine abstrakte Data Science — das sind Wettbewerbsinformationen, Hinweise für Produktverbesserungen und Marketing-Sprache, alles offen lesbar auf Amazons Servern.
Warum Amazon-Bewertungen mit Python scrapen?
Python ist für diese Aufgabe nach wie vor die erste Wahl. Es ist die am meisten gewünschte Sprache im Stack Overflow Developer Survey 2024, und sein Ökosystem — requests, BeautifulSoup, pandas, Scrapy — macht Web Scraping auch für Menschen zugänglich, die nicht Vollzeit entwickeln.
Verschiedene Teams nutzen diese Daten auf unterschiedliche Weise:
| Team | Anwendungsfall | Was extrahiert wird |
|---|---|---|
| Produkt / R&D | Wiederkehrende Beschwerden erkennen, Prioritäten setzen | 1–2-Sterne-Rezensionen, Schlüsselworthäufigkeit |
| Sales | Konkurrenz-Sentiment beobachten | Bewertungen, Trends beim Rezensionsvolumen |
| Marketing | Kundenformulierungen für Werbetexte nutzen | Positive Formulierungen, Feature-Erwähnungen |
| Ecommerce Ops | Sentiment der eigenen Produkte über die Zeit verfolgen | Sternverteilung, Anteil verifizierter Käufe |
| Marktforschung | Marktführer nach Features vergleichen | Multi-ASIN-Rezensionsdatensätze |
Eine Küchenwarenmarke wertete negative Rezensionen aus und stellte fest, dass 22 % „die Antihaftbeschichtung nutzt sich ab“ erwähnten, überarbeitete das Produkt und eroberte innerhalb von 60 Tagen wieder Platz 1 der Bestseller-Rangliste. Ein Fitness-Tracker-Anbieter fand über Rezensionstexte „Reizungen durch das Band“, identifizierte ein Latexallergie-Problem, brachte eine hypoallergene Version heraus und senkte die Retouren um 40 %. Genau dieser ROI macht den technischen Aufwand lohnenswert.
Login-Schranke: Warum dein Amazon Review Scraper plötzlich nicht mehr funktioniert
Am 14. November 2024 begann Amazon damit, für die vollständige Produkt-Bewertungsseite eine Anmeldung zu verlangen. Die Änderung wurde in Community-Foren und von Scraping-Anbietern bestätigt. Wenn du /product-reviews/{ASIN}/ in einem Inkognito-Fenster aufrufst, landest du statt bei den Bewertungen auf einer Login-Seite.
Die Symptome sind tückisch: Dein Skript erhält ein 200 OK, aber im HTML steht ein Login-Formular (name="email", id="ap_password") statt Rezensionen. Kein Fehlercode. Kein CAPTCHA. Einfach… nichts Brauchbares.
Amazon macht das aus Anti-Bot- und regionalen Compliance-Gründen. Die Durchsetzung ist inkonsistent — manchmal lädt ein frisches Browserfenster noch ein paar Rezensionen, bevor die Schranke greift, besonders auf der ersten Seite — aber für jeden Scraper im größeren Maßstab solltest du davon ausgehen, dass die Schranke immer aktiv ist.
Auch die einzelnen Amazon-Länderdomains (.de, .co.uk, .co.jp) setzen die Schranke jeweils unabhängig durch. Ein Forennutzer brachte es so auf den Punkt: „Für jedes Land ist ein eigener Login erforderlich.“ Deine .com-Cookies funktionieren also nicht auf .co.uk.
Featured Reviews vs. Full Reviews: Was ohne Login noch erreichbar ist
Amazon-Produktseiten (/dp/{ASIN}/) zeigen weiterhin ungefähr 8 „Featured Reviews“ ohne Authentifizierung an. Diese werden von Amazons Algorithmus ausgewählt und eignen sich für einen schnellen Sentiment-Check, sind aber weder sortierbar, noch filterbar, noch paginiert.
Die vollständigen Bewertungsseiten (/product-reviews/{ASIN}/) — mit Sortierung nach Neuheit, Filterung nach Sternebewertung und Seitennavigation über Hunderte von Rezensionen — erfordern einen Login.
Wenn du nur ein paar Bewertungen für einen kurzen Stimmungscheck brauchst, scrape die Produktseite. Für Hunderte oder Tausende brauchst du Authentifizierung.
Was du vor dem Start brauchst: Python-Setup und Libraries
Bevor wir Code schreiben, hier das Setup:
- Schwierigkeit: Mittelstufe (Python-Kenntnisse, grundlegendes HTML-Verständnis)
- Zeitaufwand: ca. 45 Minuten für die komplette Pipeline; ca. 10 Minuten für ein Basis-Scraping
- Du brauchst: Python 3.8+, Chrome-Browser, ein gültiges Amazon-Konto
Installiere die Kernbibliotheken:
pip install requests beautifulsoup4 lxml pandas textblob
Optional (für fortgeschrittene Sentimentanalyse):
pip install transformers torch
Was ist eine ASIN? Das ist Amazons 10-stellige Produktkennung. Du findest sie in jeder Produkt-URL — zum Beispiel ist in amazon.com/dp/B0BCNKKZ91 die ASIN B0BCNKKZ91. Diese Kennung setzt du später in die Bewertungs-URL ein.
Schritt 1: Die Login-Schranke mit Cookie-basierter Authentifizierung umgehen
Der zuverlässigste Ansatz ist: In Amazon im Browser einloggen, die Session-Cookies kopieren und in deine Python-requests.Session() einfügen. So vermeidest du CAPTCHAs und SMS-2FA, die bei Selenium-basierten Login-Automationen häufig auftreten.
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 | Nutzer-Browsing-Kennung |
at-main | Primäres Auth-Token |
sess-at-main | Sitzungsgebundene Authentifizierung |
x-main | An die E-Mail gebundene Kennung |
So extrahierst du Cookies aus Chrome DevTools
- Logge dich in Chrome bei amazon.com ein
- Öffne DevTools (F12 oder Rechtsklick → Untersuchen)
- Gehe zu Application → Storage → Cookies →
https://www.amazon.com - Suche die Cookie-Namen aus der Tabelle und kopiere die Werte
- Formatiere sie als durch Semikolons getrennte Zeichenkette für Python
Richte deine Session so ein:
import requests
session = requests.Session()
# Cookie-Werte hier 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 Anfragen dasselbe session-Objekt. So bleiben die Cookies konsistent und das Verhalten ähnelt einem echten Browser. Cookies halten unter Scraping-Last oft Tage bis Wochen, aber wenn wieder Login-Weiterleitungen auftauchen, solltest du sie im Browser erneuern.
Für andere Amazon-Marktplätze als .com ändern sich die Cookie-Namen leicht — amazon.de nutzt at-acbde statt at-main, amazon.co.uk verwendet at-acbuk und so weiter. Jeder Marktplatz braucht seine eigene unabhängige Session.
Schritt 2: Die Anfrage bauen und Rezensionen 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 Kernfunktion:
from bs4 import BeautifulSoup
import time, random
def get_soup(session, url):
time.sleep(random.uniform(2, 5)) # Höfliche Pause
response = session.get(url, timeout=15)
# Login-Schranke erkennen
if "ap_email" in response.text or "Amazon Sign-In" in response.text:
raise Exception("Login-Schranke erkannt — bitte Cookies aktualisieren")
if response.status_code != 200:
raise Exception(f"HTTP {response.status_code}")
return BeautifulSoup(response.text, "lxml")
Ein kleiner Trick, der hilft: Besuche vor der Bewertungsseite zuerst die Produktseite. Das erzeugt ein natürlicheres Browsing-Muster in deiner Session.
# Erst die 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 verwenden, um Bewertungsdaten zu extrahieren (nicht auf CSS-Klassen verlassen)
Hier scheitern die meisten Tutorials aus 2022–2023. Amazon verschleiert CSS-Klassennamen — sie ändern sich regelmäßig, und wie ein frustrierter Entwickler in einem Forenbeitrag schrieb: „Keiner von ihnen hatte auch nur ein einziges Muster bei den Klassennamen der span-Tags.“
Die Lösung: Amazon nutzt für Bewertungselemente data-hook-Attribute, und die sind bemerkenswert stabil. Das sind semantische Kennungen, auf die der eigene Frontend-Code von Amazon angewiesen ist, deshalb werden sie nicht randomisiert.
| Bewertungsfeld | Stabiler Selektor (data-hook) | Anfälliger Selektor (class) |
|---|---|---|
| Rezensionstext | [data-hook="review-body"] | .review-text-content (ändert sich) |
| Sternebewertung | [data-hook="review-star-rating"] | .a-icon-alt (mehrdeutig) |
| Rezensionstitel | [data-hook="review-title"] | .review-title (manchmal) |
| Autorenname | span.a-profile-name | Relativ stabil |
| Rezensionsdatum | [data-hook="review-date"] | .review-date (abhängig von der Region) |
| 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 verwende diese Selektoren nun seit Monaten für mehrere ASINs, und die data-hook-Attribute haben sich kein einziges Mal geändert. Die CSS-Klassen dagegen wurden im selben Zeitraum mindestens zweimal ausgetauscht.
Schritt 4: Pagination behandeln und Amazons 10-Seiten-Limit umgehen
Amazon begrenzt den Parameter pageNumber auf 10 Seiten mit jeweils 10 Rezensionen — also ein hartes Limit von etwa 100 Bewertungen pro Filterkombination. Der „Nächste Seite“-Button verschwindet nach Seite 10 einfach.
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 du mehr als 10 Seiten Amazon-Bewertungen abrufst
Der Workaround ist das Bucketing über Filter. Jede Kombination aus filterByStar und sortBy erhält ihr eigenes unabhängiges 10-Seiten-Fenster.
Stern-Filterwerte: 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, also 1.000 Bewertungen pro Produkt, erreichen — und bei Produkten mit ungleichmäßiger Sterneverteilung kommst du oft ziemlich nah an den vollständigen Datensatz heran.
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 einzigartiger Bewertungen: {len(all_reviews)}")
Zwischen den Buckets gibt es Überschneidungen, daher ist Duplikaterkennung wichtig. Ich nutze dafür schnell und pragmatisch eine Kombination aus Rezensionstitel + Autorenname — nicht perfekt, aber sie fängt den Großteil der Duplikate ab.
Schritt 5: Anti-Bot-Schutz umgehen (Rotieren, drosseln, wiederholen)
Amazon verwendet AWS WAF Bot Control, und das System ist deutlich aggressiver geworden. Einfache Gegenmaßnahmen auf nur einer Ebene — etwa nur User-Agents wechseln oder nur Verzögerungen einbauen — reichen nicht mehr aus.
| Technik | Umsetzung |
|---|---|
| Rotierende User-Agents | Zufällige Auswahl aus 10+ echten Browser-Strings |
| Exponentielles Backoff | 2s → 4s → 8s Retry-Verzögerung bei 503s |
| Request-Throttling | random.uniform(2, 5) Sekunden zwischen Seiten |
| Proxy-Rotation | Residential Proxies im Wechsel |
| Session-Fingerprint | Konsistente Cookies + Header pro Session |
| TLS-Emulation | 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)
# Blockierungen 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-Schranke — Cookies sind 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
Ein Hinweis zu Proxies: Amazon blockiert bekannte Rechenzentrums-IP-Bereiche (AWS, GCP, Azure, DigitalOcean) bereits auf Netzwerkebene. Wenn du mehr als ein paar Hundert Seiten scrapst, sind Residential Proxies praktisch Pflicht — rechne je nach Volumen mit 50–200+ US-Dollar pro Monat. Für kleinere Projekte (unter 100 Requests/Tag) funktioniert vorsichtiges Throttling von deiner Heim-IP oft völlig ausreichend.
Amazon prüft außerdem TLS-Fingerprints. Das Standard-requests-Paket von Python hat einen bekannten JA3-Hash, den WAFs oft vorab blockieren. Für produktive Scraper solltest du curl_cffi in Betracht ziehen, weil es echte Browser-TLS-Stacks emuliert. Für Scraping im Tutorial-Umfang (ein paar Hundert Seiten) reicht requests mit guten Headern meistens 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:
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 des 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 | Gutes Preis-Leistungs-Verhältnis | Macht alles, was ich brauche, nur bei schweren Apps etwas langsam... | March 10, 2025 | the United States | False |
Für den Excel-Export: df.to_excel("amazon_reviews.xlsx", index=False) (benötigt openpyxl).
Für Google Sheets funktioniert die Bibliothek gspread, erfordert aber 8+ Schritte Google-Cloud-Konfiguration — Projekt anlegen, zwei APIs aktivieren, Service-Account-Zugangsdaten erstellen, Tabelle freigeben. Wenn sich das nach mehr Aufwand anhört als das eigentliche Scraping, liegst du nicht falsch. (Genau an solchen Punkten wirkt ein Tool wie Thunderbit, das mit einem Klick nach Google Sheets exportiert, plötzlich sehr attraktiv.)
Bonus: In 5 Zeilen Python eine Sentimentanalyse auf deine Bewertungen anwenden
Die meisten Scraping-Tutorials enden beim CSV-Export. Aber erst die Sentimentbewertung macht aus Rohdaten echte Geschäftsentscheidungen.
Die schnellste Basislösung nutzt TextBlob:
from textblob import TextBlob
df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)
Das ergibt für 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 |
Spannend sind die Abweichungen — etwa eine 3-Sterne-Bewertung mit positivem Ton oder eine 5-Sterne-Bewertung mit negativer Wortwahl. Solche Unterschiede zeigen oft feinere Kundenmeinungen, die Sterne allein nicht erfassen.
Für produktionsreife Genauigkeit empfehle ich Hugging Face Transformers. VADER wurde auf Tweets trainiert, nicht auf Produktbewertungen, und Transformer-Modelle erreichen über 98 % Genauigkeit bei der Klassifikation von Reviews — deutlich besser 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 starker 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. Segmentiere den 1-Stern-Cluster und suche nach wiederkehrenden Mustern — dort steckt meist der eine behebbare Defekt.
Die ehrliche Abwägung: DIY-Python vs. kostenpflichtige Scraping-APIs vs. Thunderbit
Ich habe Python-Scraper für Amazon gepflegt, und ich sage es offen: 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 Datenanalyse. Auch in Foren berichten Nutzer über dieselbe Frustration — DIY-Skripte, die „letzten Monat noch funktioniert haben“, brauchen nun ständig Nachbesserungen.
So schneiden die drei Hauptansätze ab:
| Kriterium | DIY Python (BS4/Selenium) | Paid Scraping API | Thunderbit (No-Code) |
|---|---|---|---|
| Einrichtungszeit | 1–3 Stunden | 30 Min. (API-Key) | 2 Minuten |
| Kosten | Kostenlos (+ Proxy-Kosten) | 50–200+ $/Monat | Freier Tarif verfügbar |
| Login-Schranke | Manuelles Cookie-Management | Meist gelöst | Automatisch gelöst |
| 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 | Browserbasiert = dein Locale |
| Sentimentanalyse | Eigenen Code hinzufügen | Teilweise enthalten | Nach Excel/Sheets exportieren, überall analysieren |
| Am besten für | Lernen, volle Kontrolle | Skalierung/Produktionspipelines | Schnelle Datenzüge, Non-Dev-Teams |
Python gibt dir maximale Kontrolle und ist tatsächlich der beste Weg, um Web Scraping im Inneren zu verstehen. Bezahlte APIs (ScrapingBee, Oxylabs, Bright Data) lohnen sich für Produktionspipelines, bei denen Verfügbarkeit wichtiger ist als Kosten. Und für Teams, die Bewertungsdaten ohne Entwicklungsaufwand brauchen — etwa Ecommerce-Teams, die wöchentlich Wettbewerber beobachten, oder Marketing-Teams, die Kundensprache für Anzeigen sammeln — gibt es einen dritten Weg.
Amazon-Bewertungen mit Thunderbit scrapen (ohne Code, ohne Wartung)
Wir haben Thunderbit genau für die Fälle gebaut, in denen ein Python-Scraper zu aufwendig wird. Der Ablauf sieht so aus:
- Installiere die Thunderbit Chrome Extension
- Öffne die Amazon-Produktbewertungsseite in deinem Browser (du bist bereits eingeloggt, also ist die Login-Schranke kein Thema)
- Klicke auf „AI Suggest Fields“ — Thunderbit liest die Seite und schlägt Spalten wie Autor, Bewertung, Titel, Rezensionstext, Datum und Verifizierter Kauf vor
- Klicke auf „Scrape“ — die Daten werden sofort extrahiert, inklusive integrierter Pagination
- Exportiere nach Excel, Google Sheets, Airtable oder Notion
Der größte Vorteil: Die KI von Thunderbit liest die Seitenstruktur jedes Mal frisch ein. Keine CSS-Selektoren, die gewartet werden müssen, kein Cookie-Management, kein Anti-Bot-Code. Wenn Amazon sein HTML ändert, passt sich die KI an. Für Leser, die programmatischen Zugriff ohne komplettes Do-it-yourself wollen, bietet Thunderbit außerdem eine Extract API — strukturierte Datenerfassung per API mit KI-gestützter Felderkennung, ganz ohne Selektorpflege.
Für tiefere Einblicke in Amazon-Daten siehe auch unsere Anleitungen zu Amazon-Produkten und -Bewertungen scrapen und Amazon-Verkaufsdaten extrahieren und analysieren.
Tipps für das Scrapen von Amazon-Bewertungen im großen Maßstab mit Python
Wenn du Bewertungen über viele ASINs hinweg scrapen willst, helfen dir ein paar Gewohnheiten, Kopfschmerzen zu vermeiden:
- Batch deine ASINs und baue Pausen zwischen den Produkten ein, nicht nur zwischen den Seiten. Ich verwende 10–15 Sekunden Pause zwischen ASINs.
- Dedupliziere aggressiv. Wenn du mehrere Sternfilter- und Sortierkombinationen zusammenführst, gibt es Überschneidungen. Nutze ein Set aus
(title, author, date)-Tupeln als Deduplikationsschlüssel. - Protokolliere Fehler. Halte fest, welche ASIN-/Seiten-/Filterkombinationen fehlgeschlagen sind, damit du sie später gezielt neu versuchen kannst.
- Speichere große Projekte in einer 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ür laufendes Monitoring kannst du einen Cronjob einrichten oder Thunebit’s Scheduled Scraper nutzen — URL und Zeitplan beschreiben, und der Rest läuft ohne Server.
Weitere Ansätze findest du in unseren Beiträgen zu den besten automatisierten Web-Scraping-Tools und Daten von Websites nach Excel scrapen.
Ein kurzer Hinweis zu rechtlichen und ethischen Fragen
Amazons Nutzungsbedingungen verbieten ausdrücklich „die Verwendung von Robotern, Spider, Scraper oder anderen automatisierten Mitteln, um auf Amazon Services zuzugreifen“. Gleichzeitig war die jüngere US-Rechtsprechung für Scraper öffentlich zugänglicher Daten eher günstig. In Meta Platforms v. Bright Data (Januar 2024) entschied ein Bundesgericht, dass das Scraping öffentlich zugänglicher Daten nicht gegen die Nutzungsbedingungen verstößt, wenn der Scraper kein eingeloggter „User“ ist.
Die Feinheit: Scraping hinter einem Login — genau das behandelt dieses Tutorial — bewegt sich im Vertragsrecht, weil du Amazons Nutzungsbedingungen beim Erstellen deines Kontos akzeptiert hast. Öffentlich sichtbare Featured Reviews zu scrapen ist rechtlich weniger heikel als Scraping hinter der Login-Schranke.
Praktische Leitlinien: Veröffentliche gescrapte Daten nicht kommerziell weiter, scrape keine personenbezogenen Daten über das öffentlich Sichtbare hinaus, beachte robots.txt und hole dir bei größeren oder kommerziellen Projekten rechtlichen Rat. Das ist keine Rechtsberatung. Mehr zum rechtlichen Umfeld findest du in unserem Überblick zu rechtlichen Implikationen von Web Scraping.
Fazit: Amazon-Bewertungen mit Python scrapen oder den Code ganz überspringen
Kurze Zusammenfassung dessen, was dieser Leitfaden behandelt hat:
- Die Login-Schranke ist real, aber mit Cookie-basierter Authentifizierung lösbar — kopiere 7 Cookies aus deinem Browser und füge sie in eine
requests.Session()ein - Verwende
data-hook-Selektoren statt CSS-Klassen, damit das Extrahieren nicht alle paar Wochen kaputtgeht - Kombiniere Sternfilter und Sortieroptionen, um das 10-Seiten-Limit zu umgehen und über 500 Bewertungen pro Produkt zu erreichen
- Ergänze die Daten mit Sentimentanalyse via TextBlob für einen schnellen Einstieg oder Hugging Face Transformers für produktionsreife Genauigkeit
- Pflege Anti-Bot-Schutz: Throttling, User-Agent-Rotation, exponentielles Backoff und Residential Proxies für größere Skalen
Python gibt dir volle Kontrolle und ist der beste Weg, um zu verstehen, was unter der Haube passiert. Aber wenn dein Use Case eher lautet: „Ich brauche bis Freitag Wettbewerber-Bewertungsdaten in einer Tabelle“ statt „Ich will eine Produktionsdaten-Pipeline bauen“, dann ist der Wartungsaufwand eines eigenen Scrapers vielleicht nicht gerechtfertigt.
Thunderbit übernimmt Authentifizierung, Selektoren, Pagination und Export per Klick — probiere den Free-Tier aus und schau, ob er 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 auch unseren Thunderbit YouTube-Kanal für Video-Anleitungen zu Scraping-Workflows ansehen.
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 Authentifizierung. Für die meisten Business-Anwendungen musst du also die Login-Schranke umgehen.
2. Ist das Scrapen von Amazon-Bewertungen legal?
Amazons Nutzungsbedingungen verbieten automatisiertes Scraping. Jüngere US-Rechtsprechung (Meta v. Bright Data, 2024; hiQ v. LinkedIn) stützt jedoch das Scraping öffentlich zugänglicher Daten. Scraping hinter einem Login ist rechtlich riskanter, da du Amazons ToS bereits zugestimmt hast. Für kommerzielle Nutzung solltest du juristischen Rat einholen.
3. Wie viele Amazon-Bewertungen kann ich pro Produkt scrapen?
Amazon begrenzt Bewertungsseiten auf 10 pro Sortier- und Sternfilter-Kombination. Mit allen 5 Sternfiltern × 2 Sortierungen kannst du bis zu 100 Seiten (also ungefähr 1.000 Bewertungen) pro Produkt abrufen. Mit Keyword-Filtern liegt die theoretische Obergrenze deutlich höher, allerdings auch mit erheblichen Überschneidungen.
4. Welche Python-Bibliothek eignet sich am besten für Amazon Review Scraping?
requests + BeautifulSoup für das Parsen statischer HTML-Seiten ist die gebräuchlichste und zuverlässigste Kombination. Selenium ist hilfreich, wenn JavaScript-Rendering nötig ist. Für eine No-Code-Alternative, die Login-Schranken und Pagination automatisch übernimmt, probiere Thunderbit.
5. Wie vermeide ich Blockierungen beim Scraping von Amazon?
Wechsle User-Agent-Strings aus einem Pool von 10+ echten Browser-Strings aus, füge zufällige Pausen von 2–5 Sekunden zwischen den Requests ein, implementiere exponentielles Backoff bei 503/429-Fehlern, nutze für größere Mengen Residential Proxies (Rechenzentrums-IP-Bereiche werden oft vorab blockiert) und halte die Session-Cookies konsistent. Für einen wartungsfreien Ansatz übernimmt Thunderbit den Anti-Bot-Schutz automatisch über deine Browser-Session.
Mehr erfahren
