Vier Methoden, dieselbe Amazon-Best-Sellers-Seite, ein ganzer Samstagnachmittag und reichlich Kaffee. Zwei der Ansätze liefen erstaunlich rund, einer hat mich beinahe auf Amazons IP-Sperrliste befördert, und einer war im Grunde mit zwei Klicks erledigt. Was dabei hängen geblieben ist, fasse ich hier zusammen.
Amazon ist eine eigene Welt: 600 Millionen Produktangebote, über 310 Millionen aktive Kundenkonten und ein Best Sellers Rank (BSR), der sich stündlich neu sortiert. Wer FBA-Produkte recherchiert, Konkurrenzpreise im Blick behält oder Trends aufspüren will, bevor sie alle sehen, sitzt mit Best-Seller-Daten an der Quelle.
Nur: diese Daten sauber aus Amazon herauszubekommen und in eine Tabelle zu bringen, ist die eigentliche Kunst. Ich habe requests + BeautifulSoup, Selenium, eine Scraping-API und Thunderbit (unseren eigenen No-Code AI Web Scraper) gegeneinander antreten lassen, um zu sehen, welcher Weg tatsächlich Ergebnisse bringt – und welcher dich zuverlässig auf einer CAPTCHA-Seite abstellt.
Was sind Amazon-Bestseller – und warum solltest du dich dafür interessieren?
Der Amazon Best Sellers Rank (BSR) ist Amazons Live-Rangliste: Produkte werden innerhalb jeder Kategorie nach Verkaufsvolumen sortiert. Man kann sich das als Beliebtheitswettbewerb vorstellen, der stündlich auf Basis aktueller und historischer Verkaufszahlen neu gerechnet wird. Amazon selbst formuliert es so:
"The Amazon Best Sellers calculation is based on Amazon sales and is updated hourly to reflect recent and historical sales of every item sold on Amazon." — Amazon Seller Central
Pro Kategorie listet die Best-Sellers-Seite die Top 100 Produkte, aufgeteilt auf zwei Seiten zu je 50 Einträgen: Seite 1 deckt Rang #1–50 ab, Seite 2 Rang #51–100. Wichtig dabei – Amazon hat bestätigt, dass weder Seitenaufrufe noch Kundenbewertungen den BSR beeinflussen. Zählen tun allein die Verkäufe.
Und wer braucht das? E-Commerce-Verkäufer, die nach FBA-Produkten suchen. Vertriebsteams, die Competitive Intelligence betreiben. Operations-Teams, die Preisentwicklungen beobachten. Marktforscher, die das Wachstum ganzer Kategorien analysieren. Meine Erfahrung: Früher oder später landen diese Daten bei jedem, der auf oder gegen Amazon verkauft, in einer Tabelle.
Warum Amazon-Bestseller mit Python scrapen?
Produktrecherche von Hand frisst eine Menge Zeit. Eine McKinsey-Studie hat ergeben, dass Beschäftigte 9,3 Stunden pro Woche allein damit verbringen, Informationen zu suchen und zusammenzutragen. Übersetzt auf E-Commerce-Teams heißt das: stundenlang durch Amazon-Seiten klicken, Produktnamen und Preise abtippen, in eine Tabelle einfügen – und das Ganze nächste Woche von vorn.
Hier ein kurzer Überblick über die Anwendungsfälle, die das Scrapen von Best Sellers sinnvoll machen:
| Anwendungsfall | Was du bekommst | Wer profitiert |
|---|---|---|
| FBA-Produktrecherche | Produkte mit hoher Nachfrage und wenig Konkurrenz über BSR und Bewertungsanzahl identifizieren | Amazon-Verkäufer, Dropshipper |
| Wettbewerbsfähige Preisanalyse | Preisänderungen bei den Top-Produkten deiner Kategorie verfolgen | E-Commerce-Teams, Pricing-Analysten |
| Markttrend-Monitoring | Aufstrebende Kategorien und saisonale Veränderungen erkennen | Produktmanager, Marktforscher |
| Lead-Generierung | Listen von Top-Marken und deren Produktlinien erstellen | Vertriebsteams, B2B-Outreach |
| Wettbewerbsanalyse | Eigene Produkte mit den Marktführern der Kategorie vergleichen | Brand Manager, Strategieteams |
Der Nutzen ist messbar: Eine Salesforce-Umfrage unter 2.700 Commerce-Profis kam zu dem Ergebnis, dass KI-Tools E-Commerce-Profis im Schnitt 6,4 Stunden pro Woche sparen. Und Händler mit automatisiertem Preis-Tracking gewinnen die Buy Box in 67 % der Fälle – gegenüber 42 % bei manuellem Tracking. Das entspricht einem Umsatzplus von 37 %, weil sie schneller auf Preisänderungen reagieren.
4 Wege, Amazon-Bestseller mit Python zu scrapen: ein schneller Vergleich
Bevor es an die Schritt-für-Schritt-Anleitungen geht, hier der Direktvergleich, den ich mir zu Beginn gewünscht hätte. Die Tabelle hilft dir, die passende Methode für deine Lage zu finden:
| Kriterium | requests + BS4 | Selenium | Scraping API (z. B. Scrape.do) | Thunderbit (No-Code) |
|---|---|---|---|---|
| Einrichtungsaufwand | Mittel | Hoch (Driver, Browser) | Niedrig (API-Schlüssel) | Sehr niedrig (Chrome-Erweiterung) |
| Lazy Loading | Nein | Ja (Scroll-Simulation) | Ja (gerendertes HTML) | Ja (KI übernimmt das Rendering) |
| Anti-Bot-Resistenz | Niedrig (IP-Sperren) | Mittel (erkennbar) | Hoch (rotierende Proxies) | Hoch (Cloud- und Browser-Modus) |
| Wartungsaufwand | Hoch (Selektoren brechen) | Hoch (Driver-Updates + Selektoren) | Niedrig | Sehr niedrig (KI passt sich Layout-Änderungen an) |
| Kosten | Kostenlos | Kostenlos | Kostenpflichtig (pro Anfrage) | Kostenloses Kontingent + Paid-Pläne |
| Am besten geeignet für | Einmalige Scrapes, Lernen | JS-lastige Seiten, Login-Pflicht | Skalierung / Produktion | Nicht-Entwickler, schnelle Recherche, wiederkehrendes Monitoring |
Willst du die Grundlagen des Python-Scrapings verstehen, starte mit Methode 1 oder 2. Brauchst du produktionsreife Zuverlässigkeit, nimm Methode 3. Und wenn du Ergebnisse in zwei Klicks ohne eine Zeile Code willst, spring direkt zu Methode 4.
Bevor du startest
- Schwierigkeitsgrad: Anfänger bis Fortgeschrittene (je nach Methode)
- Benötigte Zeit: ca. 15 Minuten für Thunderbit, ca. 45 Minuten für Python-Methoden
- Was du brauchst: Python 3.8+ (für Methoden 1–3), Chrome-Browser, Thunderbit Chrome Extension (für Methode 4) und eine Amazon-Best-Sellers-Kategorie-URL als Ziel
Methode 1: Amazon-Bestseller mit requests + BeautifulSoup scrapen
Das ist der schlanke, anfängerfreundliche Ansatz – keine Browser-Automatisierung, nur HTTP-Requests und HTML-Parsing. Und ehrlich gesagt habe ich dabei am meisten über Amazons Anti-Scraping-Abwehr gelernt.
Schritt 1: Umgebung einrichten
Installiere die benötigten Pakete:
pip install requests beautifulsoup4 pandas
Dann die Imports:
import requests
from bs4 import BeautifulSoup
import pandas as pd
import random
import time
Schritt 2: Anfrage mit realistischen Headern senden
Anfragen, die nach Bot aussehen, blockt Amazon sofort. Die einfachste Gegenwehr ist ein User-Agent-Header, der einen echten Browser nachahmt. Hier ein Beispiel mit einer Auswahl aktueller, realistischer User-Agent-Strings (Quelle: Geekflare, März 2026):
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; 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",
]
headers = {"User-Agent": random.choice(USER_AGENTS)}
url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
response = requests.get(url, headers=headers)
print(response.status_code) # Should be 200
Kommt ein Statuscode 200 zurück, bist du drin. Siehst du dagegen 503 oder landest auf einer CAPTCHA-Seite, hat Amazon deine Anfrage durchschaut.
Schritt 3: Produktdaten mit BeautifulSoup parsen
Sieh dir das HTML der Amazon-Seite mit den DevTools deines Browsers an (Rechtsklick → Untersuchen). Die Produktcontainer tragen die ID gridItemRoot. In jedem Container stecken Produktname, Preis, Bewertung und URL.
soup = BeautifulSoup(response.text, "html.parser")
products = []
for item in soup.find_all("div", id="gridItemRoot"):
title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
link_tag = item.find("a", class_="a-link-normal")
title = title_tag.get_text(strip=True) if title_tag else "N/A"
price = price_tag.get_text(strip=True) if price_tag else "N/A"
url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
products.append({"Title": title, "Price": price, "URL": url})
Warnung: Die Klassennamen, die mit
_cDEzb_anfangen, sind CSS-Module-Hashes, die Amazon regelmäßig neu vergibt. Die IDgridItemRootund die Klassea-link-normalhalten länger, aber prüfe deine Selektoren grundsätzlich mit den DevTools, bevor du den Scraper loslässt.
Schritt 4: Als CSV exportieren
df = pd.DataFrame(products)
df.to_csv("amazon_best_sellers.csv", index=False)
print(f"Scraped {len(products)} products")
Was du erwarten kannst — und was schiefläuft
Bei mir hat diese Methode nur rund 30 Produkte statt 50 ausgespuckt. Kein Bug im Code – sondern Amazons Lazy Loading. Beim ersten Laden rendert die Seite nur etwa 30 Produkte; der Rest taucht erst beim Scrollen auf, und das setzt JavaScript-Ausführung voraus, die requests schlicht nicht bietet.
Weitere Einschränkungen:
- IP-Sperren kommen schnell, wenn du keine Proxy-Rotation nutzt (mich hat es nach etwa 15 schnell aufeinanderfolgenden Anfragen erwischt)
- CSS-Selektoren brechen, sobald Amazon das Layout ändert – und das passiert regelmäßig
- Pagination wird nicht out of the box unterstützt
Um Python-Scraping zu lernen, ist dieser Ansatz ideal. Für den produktiven Einsatz bleibt er fragil.
Methode 2: Amazon-Bestseller mit Selenium scrapen
Selenium räumt das Lazy-Loading-Problem aus dem Weg, indem es einen echten Browser hochfährt – etwas mehr Aufwand beim Aufsetzen, dafür landen alle 50 Produkte pro Seite im Netz.
Schritt 1: Selenium installieren
pip install selenium pandas
Gute Nachricht: Seit Selenium 4.6+ ist webdriver-manager nicht mehr nötig. Der Selenium Manager lädt die Driver von selbst herunter.
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time
import pandas as pd
options = Options()
options.add_argument("--headless=new")
options.add_argument("--window-size=1920,1080")
options.add_argument("--disable-blink-features=AutomationControlled")
driver = webdriver.Chrome(options=options)
Das Flag --headless=new (seit Chrome 109+) nutzt dieselbe Rendering-Pipeline wie das normale Chrome mit Fenster und erschwert Amazon damit das Erkennen des Browsers.
Schritt 2: Lazy Loading durch Scrollen auslösen
Genau dieser Schritt rechtfertigt den Mehraufwand von Selenium. Amazon Best Sellers lädt anfangs nur etwa 30 Produkte – der Rest kommt erst beim Scrollen nach.
def scroll_page(driver, scrolls=5, delay=2):
for _ in range(scrolls):
driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
time.sleep(delay)
driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
time.sleep(3)
scroll_page(driver)
Nach dem Scrollen sollten alle 50 Produkte im DOM stehen. Bei mir reichten 5 Page-Downs mit jeweils 2 Sekunden Pause, aber je nach Verbindung musst du daran drehen.
Schritt 3: Produktdaten extrahieren
items = driver.find_elements(By.ID, "gridItemRoot")
products = []
for item in items:
try:
title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
except:
title = "N/A"
try:
price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
except:
price = "N/A"
try:
url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
except:
url = "N/A"
products.append({"Title": title, "Price": price, "URL": url})
Jede Extraktion mit try/except abzusichern, ist hier entscheidend – manche Produkte sind nicht verfügbar oder haben fehlende Felder, und ein einzelnes fehlerhaftes Element soll dir nicht den ganzen Scrape zerschießen.
Schritt 4: Pagination behandeln
Amazon verteilt die 100 Bestseller auf zwei Seiten mit unterschiedlichen URL-Strukturen:
urls = [
"https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
"https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
]
all_products = []
for url in urls:
driver.get(url)
time.sleep(3)
scroll_page(driver)
# ... extract products as above ...
all_products.extend(products)
driver.quit()
Was du erwarten kannst
In meinem Test hat Selenium alle 50 Produkte pro Seite erwischt – ein klarer Punkt gegenüber requests + BS4. Der Haken: Es dauerte etwa 45 Sekunden pro Seite (inklusive Scroll-Pausen), und irgendwann hat es mich trotzdem geblockt, nachdem ich es ohne Proxy-Rotation zu oft laufen ließ. Selbst mit Anti-Detection-Flags bleibt Selenium für Amazons Bot-Erkennung sichtbar – für ernsthafte Skalierung brauchst du mehr (siehe Anti-Ban-Playbook weiter unten).
Weitere Schwachpunkte:
- WebDriver-Versionen können vereinzelt trotzdem nicht zusammenpassen, auch wenn der Selenium Manager das deutlich seltener macht
- CSS-Selektoren musst du anpassen, sobald Amazon sein DOM umbaut
- Hoher Speicherverbrauch – jede Browser-Instanz schluckt 200–400 MB RAM
Methode 3: Amazon-Bestseller mit einer Scraping-API scrapen
Scraping-APIs folgen dem Prinzip „die schwierigen Teile übernimmt jemand anderes“. Dienste wie Scrape.do, Oxylabs und ScrapingBee kümmern sich um Proxy-Rotation, JavaScript-Rendering und Anti-Bot-Maßnahmen – du schickst eine URL hin und bekommst HTML oder JSON zurück.
So funktioniert es
Du schickst deine Ziel-URL an den API-Endpunkt. Die API rendert die Seite mit einem echten Browser auf ihrer eigenen Infrastruktur, rotiert Proxies, knackt CAPTCHAs und liefert sauberes HTML. Dieses HTML parst du dann wie gewohnt mit BeautifulSoup.
Schritt 1: Anfrage über die API senden
Hier ein Beispiel mit Scrape.do (die Preise starten bei 29 $/Monat (ca. 27 €/Monat) für 150.000 Credits, 1 Credit = 1 Anfrage, unabhängig vom Rendering):
import requests
from bs4 import BeautifulSoup
api_token = "YOUR_API_TOKEN"
target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
response = requests.get(api_url)
soup = BeautifulSoup(response.text, "html.parser")
Ab hier ist das Parsen deckungsgleich mit Methode 1 – gleiche Selektoren, gleiche Extraktionslogik.
Realitätscheck bei den Kosten
Hier die Preise der großen APIs pro 1.000 Amazon-Anfragen, jeweils zum besten verfügbaren Tarif:
| Anbieter | Kosten pro 1.000 Anfragen | Hinweise |
|---|---|---|
| Scrape.do | ca. 0,19 $ | Pauschaltarif, keine Credit-Multiplikatoren |
| Oxylabs | ca. 1,80 $ | 5-facher Multiplikator für JS-Rendering |
| ScrapingBee | ca. 4,90 $ | 5–25-fache Multiplikatoren für Premium-Funktionen |
| Bright Data | ab ca. 5,00 $ | Umfassendste Daten (686 Felder/Produkt), aber am langsamsten (~66 Sek./Anfrage) |
Vor- und Nachteile
Vorteile: Hohe Zuverlässigkeit (~99 % Erfolgsrate bei Amazon für die Top-Anbieter), keine Driver-Wartung, Anti-Bot läuft automatisch, gut skalierbar.
Nachteile: Bezahlung pro Anfrage (bei großem Volumen summiert sich das), Parsing-Code musst du trotzdem schreiben, CSS-Änderungen bleiben ein Risiko. Bei 100.000 Seiten pro Monat ist der Kostenvergleich eindeutig: Eigenentwicklung kostet über drei Jahre rund 1.028.000 $ gegenüber 293.000 $ für einen Anbieter – also 71 % Ersparnis.
Der Break-even liegt meist zwischen 500.000 und 1 Million Anfragen pro Monat. Darunter schlägt die Zeitersparnis der API die Kosten klar.
Methode 4: Amazon-Bestseller mit Thunderbit scrapen (ohne Python)
Transparenzhinweis: Ich arbeite bei Thunderbit, behalte das beim Lesen also im Hinterkopf. Trotzdem habe ich alle vier Methoden direkt hintereinander durchgespielt, und der Unterschied bei der Zeit bis zu den Daten war beträchtlich.
Thunderbit ist ein AI Web Scraper, der als Chrome-Erweiterung läuft. Der Grundgedanke: Statt CSS-Selektoren oder Python-Code zu tippen, liest die KI die Seite und entscheidet selbst, welche Daten zu extrahieren sind. Für Amazon Best Sellers bringt Thunderbit vorgefertigte Templates mit, die per Klick funktionieren.
Schritt 1: Thunderbit Chrome Extension installieren
Geh in den Chrome Web Store und klick auf „Zu Chrome hinzufügen“. Melde dich für ein kostenloses Konto an – das Gratis-Kontingent reicht fürs Ausprobieren.
Schritt 2: Zur Amazon-Best-Sellers-Seite navigieren
Öffne in Chrome eine beliebige Amazon-Best-Sellers-Kategorieseite, zum Beispiel:
https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/
Schritt 3: Auf „AI Suggest Fields“ klicken
Öffne die Thunderbit-Seitenleiste und klick auf „AI Suggest Fields“. Die KI analysiert die Seitenstruktur und schlägt Spalten vor: Produktname, Preis, Bewertung, Bild-URL, Anbieter, Produkt-URL und Rang. Bei mir hatte sie alle relevanten Felder in rund 3 Sekunden korrekt erkannt.
Spalten lassen sich umbenennen, löschen oder ergänzen. Du kannst sogar eigene KI-Prompts pro Feld hinterlegen – etwa „als Electronics/Apparel/Home kategorisieren“, um jedem Produkt ein Kategorie-Tag zu verpassen.
Schritt 4: Auf „Scrape“ klicken
Klick auf den Button „Scrape“. Thunderbit füllt eine strukturierte Tabelle mit allen Produktdaten der Seite. Im Cloud-Modus verarbeitet es bis zu 50 Seiten parallel und kümmert sich automatisch um Lazy Loading und Pagination.
Schritt 5: Kostenlos exportieren
Klick auf „Export“ und such dir das Ziel aus: Excel, Google Sheets, Airtable oder Notion. Alle Exporte sind in jedem Plan kostenlos – keine versteckten Gebühren.
Der komplette Ablauf war bei mir nach rund 90 Sekunden durch – vom Öffnen der Seite bis zur fertigen Tabelle. Zum Vergleich: Methode 1 brauchte etwa 20 Minuten (mit Debugging des Lazy-Loading-Problems), Methode 2 etwa 35 Minuten (mit Selenium-Einrichtung) und Methode 3 etwa 15 Minuten (mit Anlegen des API-Kontos).
Warum Thunderbit gut mit Amazon funktioniert
Weil die KI die Seite jedes Mal frisch einliest, gewöhnt sie sich von allein an Layout-Änderungen – keine CSS-Selektoren, die du pflegen müsstest. Damit verschwindet die häufigste Klage aus Scraping-Foren: „Ein einfacher Web Scraper reicht nicht, man muss ständig alle möglichen Fallbacks für Elementänderungen einbauen.“ Baut Amazon sein DOM um, musst du nichts anfassen.
Der Cloud-Scraping-Modus regelt Proxy-Rotation, Rendering und Anti-Bot-Maßnahmen unauffällig im Hintergrund. Für alle, die einfach eine Lösung wollen, die sofort läuft, fällt der ganze Anti-Ban-Stress weg.
Das Anti-Ban-Playbook: So vermeidest du Blockierungen durch Amazon
Amazons Bot-Erkennung ist scharf. Beim Testen hat es meine IP zeitweise gesperrt, und in Foren liest man Ähnliches: „Überall Fehler, Amazon hat mich sogar auf die Startseite umgeleitet.“ Wer den Python-Weg geht (Methoden 1–3), kommt an diesem Abschnitt nicht vorbei.
Hier eine Strategie in Stufen, von einfach bis fortgeschritten:
1. User-Agent-Strings rotieren
Immer denselben User-Agent zu senden, ist ein Warnsignal. Nimm die Auswahl von 5+ Strings aus dem Codebeispiel in Methode 1 und zieh pro Anfrage zufällig einen heraus:
headers = {"User-Agent": random.choice(USER_AGENTS)}
2. Zufällige Pausen zwischen Anfragen einbauen
Feste Wartezeiten sind erkennbar (Muster). Zufällige Pausen sind sicherer:
time.sleep(random.uniform(2, 5))
Meine Beobachtung: 2–5 Sekunden zwischen Anfragen bleiben bei kleinen Batches (unter 50 Anfragen) unauffällig. Bei größeren Läufen geh lieber auf 3–7 Sekunden.
3. Proxy-Rotation verwenden
Das ist der große Hebel. Proxyway-Benchmarks zeigen, dass Residential Proxies auf Amazon im Schnitt etwa 94 % Erfolgsrate erreichen, Datacenter-Proxies dagegen nur etwa 59 % – ein Abstand von 35 Prozentpunkten. Amazons Erkennung setzt auf TLS-Fingerprinting, Verhaltensanalyse und Ratenbegrenzung pro IP, weshalb klassische Datacenter-IPs oft innerhalb von Sekunden auffliegen.
Residential Proxies kosten mehr (je nach Anbieter 2–12 $ pro GB), liefern aber deutlich zuverlässiger. Beispiel:
proxies = {
"http": "http://user:pass@residential-proxy.example.com:8080",
"https": "http://user:pass@residential-proxy.example.com:8080"
}
response = requests.get(url, headers=headers, proxies=proxies)
4. Browser-Fingerprint härten (Selenium)
options.add_argument('--disable-blink-features=AutomationControlled')
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option('useAutomationExtension', False)
# Nach der Initialisierung des Drivers navigator.webdriver entfernen
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
})
5. Sessions und Cookies verwalten
Behältst du Cookies über mehrere Anfragen hinweg bei, wirkt dein Scraper eher wie eine echte Nutzersitzung:
session = requests.Session()
# Erst die Startseite besuchen, um realistische Cookies zu erhalten
session.get("https://www.amazon.com", headers=headers)
time.sleep(2)
# Dann die Zielseite scrapen
response = session.get(target_url, headers=headers)
6. Wann du dir den Aufwand komplett sparen solltest
Hast du keine Lust, das alles zu managen, übernimmt Thunderbits Cloud-Scraping Proxy-Rotation, Rendering und Anti-Bot-Maßnahmen unsichtbar für dich. Auch Scraping-APIs decken die meisten dieser Punkte standardmäßig ab. Meine Erfahrung: Das Debuggen von Anti-Ban-Problemen zieht sich oft länger hin als das Schreiben des eigentlichen Scrapers – deshalb hat der „läuft einfach“-Ansatz echten ROI.
Subpage-Enrichment: Produktdetailseiten für reichere Daten scrapen
Die Best-Sellers-Listing-Seite liefert nur Basisinfos – Titel, Preis, Bewertung, Rang. Der wahre Mehrwert für FBA-Recherche steckt jedoch auf den einzelnen Produktdetailseiten. Das geht dir verloren, wenn du nur die Listing-Seite scrapst:
| Feld | Listing-Seite | Produktdetailseite |
|---|---|---|
| Produktname | ✅ | ✅ |
| Preis | ✅ | ✅ |
| Bewertung | ✅ | ✅ |
| BSR-Rang | ✅ | ✅ (inkl. Unterkategorie-Rängen) |
| Marke | ❌ | ✅ |
| ASIN | ❌ | ✅ |
| Datum der ersten Verfügbarkeit | ❌ | ✅ |
| Maße/Gewicht | ❌ | ✅ |
| Anzahl der Verkäufer | ❌ | ✅ |
| Stichpunkt-Features | ❌ | ✅ |
| Buy-Box-Inhaber | ❌ | ✅ |
Das Feld „Datum der ersten Verfügbarkeit“ ist besonders aufschlussreich – es verrät, wie lange ein Produkt schon am Markt ist, ein wichtiges Signal für die Wettbewerbsanalyse. Auch die Anzahl der Verkäufer und der Buy-Box-Inhaber helfen dir abzuschätzen, ob sich eine Nische lohnt (hält Amazon selbst mehr als 30 % Buy-Box-Anteil, wird der Einstieg extrem hart).
Python-Ansatz: Über Produkt-URLs iterieren
Wenn du die Produkt-URLs von der Listing-Seite gesammelt hast, geh mit einer Pause durch jede einzelne:
for product in products:
time.sleep(random.uniform(3, 6))
detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
detail_soup = BeautifulSoup(detail_response.text, "html.parser")
# Marke extrahieren
brand_tag = detail_soup.find("a", id="bylineInfo")
product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
# ASIN aus Quellcode oder URL extrahieren
# Datum der ersten Verfügbarkeit aus der Produktdetails-Tabelle extrahieren
# ... weitere Felder ...
Achtung: 100 einzelne Produktseiten nacheinander anzusteuern, erhöht das Blockierungsrisiko spürbar. Plan Proxy-Rotation und längere Pausen ein.
Thunderbit-Ansatz: Subpage-Scraping mit einem Klick
Sobald du die Listing-Seite in eine Tabelle gescrapt hast, klick in Thunderbit auf „Scrape Subpages“. Die KI ruft dann jede Produkt-URL auf und ergänzt die Tabelle automatisch um weitere Spalten – Marke, ASIN, Spezifikationen, Features. Kein zusätzlicher Code, keine Selektoren, kein Setup. Das ist besonders praktisch für E-Commerce-Teams, die ein vollständiges Bild für Sourcing-Entscheidungen brauchen, aber keinen Detailseiten-Parser schreiben und pflegen wollen.
Wiederkehrende Scrapes automatisieren: Best Sellers über Zeit beobachten
Ein einmaliger Scrape ist nützlich, doch der eigentliche Wettbewerbsvorteil liegt im laufenden Monitoring. Welche Produkte steigen, welche fallen, welche Trends sich früh abzeichnen, wie sich Preise über Wochen oder Monate bewegen – das trennt die gelegentliche Recherche von datengetriebenen Entscheidungen.
Python-Ansatz: Planung mit Cron
Unter Linux/Mac planst du dein Python-Skript mit cron. Hier der Crontab-Eintrag für einen täglichen Scrape um 8 Uhr morgens:
0 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1
Für einen wöchentlichen Scrape montags um 9 Uhr:
0 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1
Unter Windows erledigt der Task Scheduler dasselbe. Für eine dauerhafte Planung, ohne den Laptop laufen zu lassen, kannst du auf eine VPS oder AWS Lambda deployen – das treibt allerdings die Infrastruktur-Komplexität nach oben.
Bau Logging und Fehlermeldungen ein, damit fehlgeschlagene Läufe auffallen. Es gibt nichts Ärgerlicheres, als zwei Wochen später festzustellen, dass der Scraper still und leise kaputt war.
Thunderbit-Ansatz: Scheduled Scraper in natürlicher Sprache
Mit Thunderbits Scheduled Scraper beschreibst du das Intervall in natürlicher Sprache – tipp „jeden Montag um 9 Uhr“ oder „jeden Tag um 8 Uhr“, und die KI versteht den Zeitplan. Die Scrapes laufen auf Thunderbits Cloud-Servern (kein Browser und kein Rechner muss an sein), und die Daten gehen automatisch nach Google Sheets oder Airtable. So entsteht ein Live-Monitoring-Dashboard ganz ohne Server-Management – wie gemacht für Operationsteams, die dauerhaften Einblick wollen, aber keinen DevOps-Aufwand.
Rechtliche und ethische Überlegungen beim Scraping von Amazon
Ich bin kein Anwalt, und das hier ist keine Rechtsberatung. Aber die rechtliche Lage in einem Scraping-Tutorial einfach auszublenden, wäre fahrlässig – in Foren sprechen Nutzer das Thema Nutzungsbedingungen ausdrücklich an, und das aus gutem Grund.
Amazons robots.txt: Stand 2026 enthält Amazons robots.txt über 80 konkrete Disallow-Pfade, aber /gp/bestsellers/ ist für Standard-User-Agents NICHT ausdrücklich gesperrt. 35+ KI-spezifische User-Agents (ClaudeBot, GPTBot, Scrapy usw.) bekommen dagegen ein pauschales Disallow: /. Dass etwas nicht ausdrücklich verboten ist, heißt aber nicht, dass Amazon Scraping gutheißt.
Amazons Nutzungsbedingungen: Amazons Conditions of Use (aktualisiert im Mai 2025) untersagen ausdrücklich, „automatisierte Prozesse oder Technologien zu verwenden, um auf Teile der Amazon-Website zuzugreifen, sie abzurufen, zu kopieren oder zu überwachen“, sofern keine schriftliche Erlaubnis vorliegt. Das ist nicht bloß Theorie – Amazon verklagte Perplexity AI im November 2025 wegen unbefugten automatisierten Zugriffs und erwirkte eine einstweilige Verfügung.
Der Präzedenzfall hiQ gegen LinkedIn: In hiQ Labs v. LinkedIn (Ninth Circuit, 2022) entschied das Gericht, dass das Scrapen öffentlich verfügbarer Daten wahrscheinlich nicht gegen den Computer Fraud and Abuse Act verstößt. Doch hiQ einigte sich am Ende und stellte das Scraping ein – ein Sieg beim CFAA schützt nicht vor Klagen wegen Vertragsbruch.
Praktische Leitlinien:
- Nur öffentlich verfügbare Daten scrapen (Preise, BSR, Produkttitel – keine personenbezogenen Daten)
- Rate Limits respektieren und Server nicht überlasten
- Daten für legitime Competitive Intelligence nutzen
- Vor Scraping in großem Maßstab eigenen Rechtsrat einholen
- Im Hinterkopf behalten: Inzwischen gibt es über 20 US-Bundesstaaten mit umfassender Datenschutzgesetzgebung – wer DACH-Daten verarbeitet, sollte zusätzlich die DSGVO im Blick haben
Thunderbits Cloud-Scraping setzt auf standardmäßige, browserähnliche Anfrage-Muster, aber die Einhaltung solltest du grundsätzlich mit deinem eigenen Rechtsbeistand klären.
Welche Methode solltest du verwenden? Eine schnelle Entscheidungshilfe
Die Kurzfassung:
- „Ich lerne Python und will ein Wochenendprojekt.“ → Methode 1 (requests + BeautifulSoup). Du lernst viel über HTTP-Anfragen, HTML-Parsing und Amazons Bot-Schutz.
- „Ich muss JavaScript-lastige Seiten oder eingeloggte Sessions scrapen.“ → Methode 2 (Selenium). Aufwendiger, aber dynamische Inhalte werden sauber verarbeitet.
- „Ich betreibe Scrapes produktiv und in großem Umfang.“ → Methode 3 (Scraping API). Lass jemand anderen Proxies und Rendering managen. Der Total Cost of Ownership spricht unter 500K Anfragen pro Monat eher für APIs.
- „Ich bin kein Entwickler und brauche Daten in 2 Minuten.“ → Methode 4 (Thunderbit). Kein Code, keine Selektoren, keine Wartung.
- „Ich brauche laufendes Monitoring ohne Serververwaltung.“ → Thunderbit Scheduled Scraper. Einrichten und vergessen.
Fazit und wichtigste Erkenntnisse
Nach einem Wochenende Testen bleibt das hier hängen:
requests + BeautifulSoup ist top zum Lernen, aber das Lazy-Loading-Problem (nur etwa 30 von 50 Produkten) und die brüchigen CSS-Selektoren machen es für den produktiven Einsatz unbrauchbar.
Selenium löst das Lazy-Loading-Problem und holt alle 50 Produkte pro Seite, ist aber langsam, speicherhungrig und fliegt bei Amazons Bot-Schutz trotzdem auf.
Scraping-APIs bieten die beste Zuverlässigkeit für den produktiven Betrieb – ~99 % Erfolgsrate bei Amazon – aber die Kosten klettern, und Parsing-Code musst du weiterhin selbst schreiben.
Thunderbit war mit Abstand der schnellste Weg bis zu den Daten. Die KI fängt Layout-Änderungen, Lazy Loading, Pagination und Anti-Bot-Maßnahmen ohne jede Konfiguration ab. Für nicht-technische Nutzer oder Teams, die wiederkehrende Daten ohne DevOps brauchen, ist das die praktischste Option.
Die wichtigste Lektion? Amazons Anti-Bot-Schutz und die häufigen Layout-Änderungen sorgen dafür, dass wartungsarme Lösungen auf lange Sicht am meisten Zeit sparen. Jede Stunde, die in kaputte Selektoren und rotierende Proxies fließt, fehlt dir bei der eigentlichen Analyse.
Du willst den No-Code-Weg testen? Thunderbits kostenloses Kontingent gibt dir genug Credits, um ein paar Best-Sellers-Kategorien zu scrapen und die Ergebnisse mit eigenen Augen zu sehen. Lieber der Python-Weg? Mit den Codebeispielen oben kommst du schnell rein. So oder so hast du danach Amazon-Bestseller-Daten in einer Tabelle statt in einem offenen Browser-Tab.
Mehr zu Web-Scraping-Ansätzen findest du in unseren Anleitungen zu Amazon-Produkten und Bewertungen scrapen, Daten von Websites nach Excel extrahieren und den besten KI-Web-Scrapern. Außerdem gibt es Schritt-für-Schritt-Videos auf dem Thunderbit YouTube-Kanal.
Mehr erfahren
