Ich habe 4 Wege getestet, Amazon-Bestseller mit Python zu scrapen ...

Letztes Wochenende habe ich eine ganze Kanne Kaffee durchgezogen, während ich Amazon's Best-Sellers-Seite auf vier verschiedene Arten gescraped habe. Zwei Methoden haben richtig gut funktioniert, eine hat mich fast auf die IP-Blacklist gebracht, und eine brauchte im Grunde nur zwei Klicks. Hier ist alles, was ich dabei gelernt habe.

Amazon ist ein riesiger Marktplatz — , und ein Best Sellers Rank (BSR)-System, das stündlich aktualisiert wird. Wenn du FBA-Produktrecherche, Wettbewerbsanalyse bei Preisen oder einfach Trends erkennen willst, bevor es deine Konkurrenz merkt, dann sind Best-Seller-Daten pures Gold.

Aber diese Daten aus Amazon herauszuziehen und in eine Tabelle zu packen? Genau da wird’s spannend. Ich habe requests + BeautifulSoup, Selenium, eine Scraping-API und (unseren eigenen No-Code AI Web Scraper) getestet, um herauszufinden, welcher Ansatz wirklich liefert — und welche dich am Ende nur auf einer CAPTCHA-Seite landen lassen.

Was sind Amazon-Bestseller – und warum solltest du dich dafür interessieren?

Der Amazon Best Sellers Rank (BSR) ist Amazons Echtzeit-Rangliste und ordnet Produkte innerhalb jeder Kategorie nach Verkaufsvolumen ein. Stell dir das wie einen Beliebtheitswettbewerb vor, der stündlich anhand aktueller und historischer Verkaufsdaten neu berechnet wird. Amazon beschreibt 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." —

Die Best-Sellers-Seite zeigt die Top 100 Produkte pro Kategorie, verteilt auf zwei Seiten mit je 50 Einträgen. Seite 1 umfasst Rang #1–50, Seite 2 Rang #51–100. Amazon hat bestätigt, dass Seitenaufrufe und Kundenbewertungen den BSR NICHT beeinflussen — entscheidend sind nur die Verkäufe.

Wer braucht diese Daten? E-Commerce-Verkäufer auf der Suche nach FBA-Produkten, Vertriebsteams für Competitive Intelligence, Operations-Teams zur Beobachtung von Preisentwicklungen und Marktforscher, die Kategorie-Wachstum analysieren. Aus meiner Erfahrung braucht am Ende jede Person, die auf oder gegen Amazon verkauft, diese Daten irgendwann in einer Tabelle.

Warum Amazon-Bestseller mit Python scrapen?

Manuelle Produktrecherche kostet brutal viel Zeit. Eine hat gezeigt, dass Mitarbeitende 9,3 Stunden pro Woche allein mit dem Suchen und Sammeln von Informationen verbringen. Für E-Commerce-Teams heißt das: stundenlang Amazon-Seiten anklicken, Produktnamen und Preise kopieren und in Tabellen einfügen — nur um das Ganze nächste Woche wieder von vorn zu machen.

Hier ein kurzer Überblick über die Anwendungsfälle, die das Scrapen von Best Sellers sinnvoll machen:

Der Nutzen ist real: Eine unter 2.700 Commerce-Profis ergab, dass KI-Tools E-Commerce-Profis im Schnitt sparen. Und Händler, die automatisiertes Preis-Tracking nutzen, gewinnen die Buy Box in gegenüber 42 % bei manuellen Trackern — das entspricht einem Umsatzplus von 37 % durch schnellere Reaktionen auf Preisänderungen.

4 Wege, Amazon-Bestseller mit Python zu scrapen: ein schneller Vergleich

Bevor wir in die Schritt-für-Schritt-Anleitungen einsteigen, hier der Direktvergleich, den ich mir zu Beginn gewünscht hätte. Die Tabelle sollte dir helfen, die richtige Methode für deine Situation zu wählen:

Wenn du die Grundlagen des Python-Scrapings lernen willst, fang mit Methode 1 oder 2 an. Wenn du produktionsreife Zuverlässigkeit brauchst, nimm Methode 3. Wenn du Ergebnisse in zwei Klicks ohne Code willst, geh 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, (für Methode 4) und eine Amazon-Best-Sellers-Kategorie-URL als Ziel

Methode 1: Amazon-Bestseller mit requests + BeautifulSoup scrapen

Das ist der einfache, anfängerfreundliche Ansatz — keine Browser-Automatisierung, nur HTTP-Requests und HTML-Parsing. Dabei habe ich auch am meisten über Amazons Anti-Scraping-Abwehr gelernt.

Schritt 1: Umgebung einrichten

Installiere die benötigten Pakete:

1pip install requests beautifulsoup4 pandas

Dann die Imports:

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import random
5import time

Schritt 2: Anfrage mit realistischen Headern senden

Amazon blockiert Anfragen, die wie Bots wirken. Die einfachste Verteidigung ist ein User-Agent-Header, der einen echten Browser imitiert. Hier ein Beispiel mit einer Auswahl aktueller, realistischer User-Agent-Strings (Quelle: , März 2026):

1USER_AGENTS = [
2    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
3    "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",
4    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
5    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; 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]
8headers = {"User-Agent": random.choice(USER_AGENTS)}
9url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
10response = requests.get(url, headers=headers)
11print(response.status_code)  # Should be 200

Wenn du einen 200-Statuscode bekommst, bist du drin. Wenn du 503 siehst oder auf eine CAPTCHA-Seite weitergeleitet wirst, hat Amazon deine Anfrage erkannt.

Schritt 3: Produktdaten mit BeautifulSoup parsen

Untersuche das HTML der Amazon-Seite mit den DevTools deines Browsers (Rechtsklick → Untersuchen). Die Produktcontainer verwenden die ID gridItemRoot. Innerhalb jedes Containers findest du Produktname, Preis, Bewertung und URL.

1soup = BeautifulSoup(response.text, "html.parser")
2products = []
3for item in soup.find_all("div", id="gridItemRoot"):
4    title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
5    price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
6    link_tag = item.find("a", class_="a-link-normal")
7    title = title_tag.get_text(strip=True) if title_tag else "N/A"
8    price = price_tag.get_text(strip=True) if price_tag else "N/A"
9    url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
10    products.append({"Title": title, "Price": price, "URL": url})

Warnung: Die mit _cDEzb_ beginnenden Klassennamen sind CSS-Module-Hashes, die Amazon regelmäßig neu generiert. Die ID gridItemRoot und die Klasse a-link-normal sind stabiler, aber prüfe die Selektoren immer mit den DevTools, bevor du deinen Scraper startest.

Schritt 4: Als CSV exportieren

1df = pd.DataFrame(products)
2df.to_csv("amazon_best_sellers.csv", index=False)
3print(f"Scraped {len(products)} products")

Was du erwarten kannst — und was schiefläuft

In meinem Test hat diese Methode nur etwa 30 Produkte statt 50 geliefert. Das ist kein Fehler im Code — sondern Amazons Lazy Loading. Beim ersten Laden werden nur rund 30 Produkte gerendert; der Rest erscheint erst nach dem Scrollen, was JavaScript-Ausführung erfordert, die requests nicht leisten kann.

Weitere Einschränkungen:

• IP-Sperren treten schnell auf, wenn keine Proxy-Rotation genutzt wird (ich wurde nach etwa 15 Anfragen in kurzer Folge blockiert)
• CSS-Selektoren brechen, sobald Amazon das Seitenlayout ändert — und das passiert regelmäßig
• Keine Pagination-Unterstützung out of the box

Zum Lernen von Python-Scraping ist dieser Ansatz super. Für den produktiven Einsatz ist er jedoch fragil.

Methode 2: Amazon-Bestseller mit Selenium scrapen

Selenium löst das Lazy-Loading-Problem, indem es einen echten Browser startet — etwas aufwendiger einzurichten, dafür werden aber alle 50 Produkte pro Seite erfasst.

Schritt 1: Selenium installieren

1pip install selenium pandas

Gute Nachricht: Seit Selenium 4.6+ brauchst du webdriver-manager nicht mehr. Selenium Manager übernimmt das Herunterladen der Driver automatisch.

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.common.keys import Keys
5import time
6import pandas as pd
7options = Options()
8options.add_argument("--headless=new")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("--disable-blink-features=AutomationControlled")
11driver = webdriver.Chrome(options=options)

Das Flag --headless=new (eingeführt in Chrome 109+) nutzt dieselbe Rendering-Pipeline wie normales Chrome mit Fenster und macht es Amazon schwerer, den Browser zu erkennen.

Schritt 2: Lazy Loading durch Scrollen auslösen

Das ist der Schritt, der Selenium den Extraaufwand wert macht. Amazon Best Sellers lädt anfangs nur etwa 30 Produkte — der Rest erscheint erst nach dem Scrollen.

1def scroll_page(driver, scrolls=5, delay=2):
2    for _ in range(scrolls):
3        driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
4        time.sleep(delay)
5driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
6time.sleep(3)
7scroll_page(driver)

Nach dem Scrollen sollten alle 50 Produkte im DOM gerendert sein. In meinem Test waren 5 Page-Downs mit 2 Sekunden Pause ausreichend, je nach Verbindung musst du das aber anpassen.

Schritt 3: Produktdaten extrahieren

1items = driver.find_elements(By.ID, "gridItemRoot")
2products = []
3for item in items:
4    try:
5        title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
6    except:
7        title = "N/A"
8    try:
9        price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
10    except:
11        price = "N/A"
12    try:
13        url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
14    except:
15        url = "N/A"
16    products.append({"Title": title, "Price": price, "URL": url})

Jede Extraktion mit try/except abzusichern ist wichtig — manche Produkte sind vielleicht nicht verfügbar oder haben fehlende Felder, und du willst nicht, dass ein fehlerhaftes Element den ganzen Scrape abstürzen lässt.

Schritt 4: Pagination behandeln

Amazon verteilt die 100 Bestseller auf zwei Seiten mit unterschiedlichen URL-Strukturen:

1urls = [
2    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
3    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
4]
5all_products = []
6for url in urls:
7    driver.get(url)
8    time.sleep(3)
9    scroll_page(driver)
10    # ... extract products as above ...
11    all_products.extend(products)
12driver.quit()

Was du erwarten kannst

In meinem Test hat Selenium alle 50 Produkte pro Seite erfasst — ein klarer Sieg gegenüber requests + BS4. Der Nachteil: Es dauerte etwa 45 Sekunden pro Seite (inklusive Scroll-Pausen), und ich wurde trotzdem irgendwann blockiert, nachdem ich es ohne Proxy-Rotation zu oft ausgeführt hatte. Selenium ist selbst mit Anti-Detection-Flags für Amazons Bot-Erkennung noch sichtbar — für ernsthafte Skalierung brauchst du zusätzliche Maßnahmen (siehe Anti-Ban-Playbook unten).

Weitere Schwachpunkte:

• WebDriver-Versionen können gelegentlich dennoch nicht zusammenpassen, auch wenn Selenium Manager das deutlich seltener macht
• CSS-Selektoren müssen angepasst werden, sobald Amazon sein DOM ändert
• Hoher Speicherverbrauch — jede Browser-Instanz frisst 200–400 MB RAM

Methode 3: Amazon-Bestseller mit einer Scraping-API scrapen

Scraping-APIs sind der Ansatz „Lass jemand anderen die schwierigen Teile übernehmen“. Dienste wie Scrape.do, Oxylabs und ScrapingBee kümmern sich um Proxy-Rotation, JavaScript-Rendering und Anti-Bot-Maßnahmen — du sendest einfach eine URL und bekommst HTML oder JSON zurück.

So funktioniert es

Du sendest deine Ziel-URL an den API-Endpunkt. Die API rendert die Seite mit einem echten Browser auf ihrer Infrastruktur, rotiert Proxies, behandelt CAPTCHAs und gibt sauberes HTML zurück. Dieses HTML parst du dann wie gewohnt mit BeautifulSoup.

Schritt 1: Anfrage über die API senden

Hier ein Beispiel mit Scrape.do (die Preise beginnen bei 29 $/Monat für 150.000 Credits, 1 Credit = 1 Anfrage unabhängig vom Rendering):

1import requests
2from bs4 import BeautifulSoup
3api_token = "YOUR_API_TOKEN"
4target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
5api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
6response = requests.get(api_url)
7soup = BeautifulSoup(response.text, "html.parser")

Ab hier ist das Parsen identisch zu Methode 1 — gleiche Selektoren, gleiche Extraktionslogik.

Realitätscheck bei den Kosten

Hier sind die Preise der großen APIs pro 1.000 Amazon-Anfragen zum jeweils besten verfügbaren Tarif:

Vor- und Nachteile

Vorteile: Hohe Zuverlässigkeit ( bei Amazon für Top-Anbieter), keine Driver-Wartung, Anti-Bot wird automatisch behandelt, gut skalierbar.

Nachteile: Bezahlung pro Anfrage (die Kosten summieren sich bei großem Volumen), du musst trotzdem Parsing-Code schreiben, CSS-Änderungen bleiben ein Risiko. Bei 100.000 Seiten pro Monat ist der Kostenvergleich deutlich: Eigenentwicklung kostet über drei Jahre etwa — also 71 % Ersparnis.

Der Break-even liegt meist bei 500.000 bis 1 Million Anfragen pro Monat. Darunter überwiegt die Zeitersparnis der API klar die Kosten.

Methode 4: Amazon-Bestseller mit Thunderbit scrapen (ohne Python)

Transparenzhinweis: Ich arbeite bei Thunderbit, also nimm diesen Abschnitt mit diesem Kontext. Trotzdem habe ich alle vier Methoden wirklich direkt nacheinander getestet, und der Unterschied bei der Zeit bis zu den Daten war enorm.

ist ein AI Web Scraper, der als Chrome-Erweiterung läuft. Die Grundidee: Statt CSS-Selektoren oder Python-Code zu schreiben, liest die KI die Seite und erkennt selbst, welche Daten extrahiert werden sollen. Für Amazon Best Sellers gibt es bei Thunderbit vorgefertigte Templates, die mit einem Klick funktionieren.

Schritt 1: Thunderbit Chrome Extension installieren

Gehe zum und klicke auf „Zu Chrome hinzufügen“. Melde dich für ein kostenloses Konto an — das Gratis-Kontingent reicht aus, um es auszuprobieren.

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 klicke auf „AI Suggest Fields“. Die KI analysiert die Seitenstruktur und schlägt Spalten vor: Produktname, Preis, Bewertung, Bild-URL, Anbieter, Produkt-URL und Rang. In meinem Test wurden alle relevanten Felder innerhalb von etwa 3 Sekunden korrekt erkannt.

Du kannst Spalten umbenennen, entfernen oder hinzufügen. Du kannst sogar eigene KI-Prompts pro Feld hinzufügen — zum Beispiel „als Electronics/Apparel/Home kategorisieren“, um jedem Produkt ein Kategorie-Tag zuzuweisen.

Schritt 4: Auf „Scrape“ klicken

Klicke auf den Button „Scrape“. Thunderbit füllt eine strukturierte Tabelle mit allen Produktdaten der Seite. Im Cloud-Modus verarbeitet es bis zu 50 Seiten gleichzeitig parallel und übernimmt Lazy Loading sowie Pagination automatisch.

Schritt 5: Kostenlos exportieren

Klicke auf „Export“ und wähle dein Ziel: Excel, Google Sheets, Airtable oder Notion. Alle Exporte sind in jedem Plan kostenlos — ohne versteckte Gebühren.

Der gesamte Ablauf dauerte bei mir rund 90 Sekunden — vom Öffnen der Seite bis zur vollständigen Tabelle. Zum Vergleich: Methode 1 dauerte etwa 20 Minuten (inklusive Debugging des Lazy-Loading-Problems), Methode 2 etwa 35 Minuten (inklusive Selenium-Einrichtung) und Methode 3 etwa 15 Minuten (inklusive API-Kontoerstellung).

Warum Thunderbit gut mit Amazon funktioniert

Weil die KI die Seite jedes Mal frisch liest, passt sie sich automatisch an Layout-Änderungen an — keine CSS-Selektoren, die man pflegen müsste. Damit wird die häufigste Beschwerde in Scraping-Foren direkt entschärft: „Ein einfacher Web Scraper reicht nicht, man muss ständig alle möglichen Fallbacks für Elementänderungen einbauen.“ Wenn Amazon sein DOM ändert, musst du nichts aktualisieren.

Der Cloud-Scraping-Modus übernimmt Proxy-Rotation, Rendering und Anti-Bot-Maßnahmen transparent im Hintergrund. Für Nutzer, die einfach eine Lösung wollen, die sofort funktioniert, entfällt damit der komplette Anti-Ban-Stress.

Das Anti-Ban-Playbook: So vermeidest du Blockierungen durch Amazon

Amazons Bot-Erkennung ist aggressiv. Ich wurde beim Testen vorübergehend mit meiner IP blockiert, und Nutzer in Foren berichten Ähnliches: „Überall Fehler, Amazon hat mich sogar auf die Startseite umgeleitet.“ Wenn du den Python-Weg gehst (Methoden 1–3), ist dieser Abschnitt entscheidend.

Hier eine mehrstufige Strategie, von einfach bis fortgeschritten:

1. User-Agent-Strings rotieren

Denselben User-Agent immer wieder zu senden, ist ein Warnsignal. Nutze die Auswahl von 5+ Strings aus dem Codebeispiel in Methode 1 und wähle pro Anfrage zufällig einen aus:

1headers = {"User-Agent": random.choice(USER_AGENTS)}

2. Zufällige Pausen zwischen Anfragen einbauen

Feste Wartezeiten sind erkennbar (Muster). Zufällige Pausen sind sicherer:

1time.sleep(random.uniform(2, 5))

Ich habe festgestellt, dass 2–5 Sekunden zwischen Anfragen bei kleinen Batches (unter 50 Anfragen) unauffällig bleiben. Bei größeren Läufen solltest du eher auf 3–7 Sekunden gehen.

3. Proxy-Rotation verwenden

Das ist der große Hebel. zeigen, dass Residential Proxies auf Amazon im Schnitt etwa 94 % Erfolgsrate erreichen, während Datacenter-Proxies bei etwa 59 % liegen — ein Unterschied von 35 Prozentpunkten. Amazons Erkennung nutzt TLS-Fingerprinting, Verhaltensanalyse und Ratenbegrenzung pro IP, daher werden klassische Datacenter-IPs oft innerhalb von Sekunden markiert.

Residential Proxies sind teurer (je nach Anbieter 2–12 $ pro GB), aber deutlich zuverlässiger. Beispiel:

1proxies = {
2    "http": "http://user:pass@residential-proxy.example.com:8080",
3    "https": "http://user:pass@residential-proxy.example.com:8080"
4}
5response = requests.get(url, headers=headers, proxies=proxies)

4. Browser-Fingerprint härten (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# Nach der Initialisierung des Drivers navigator.webdriver entfernen
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. Sessions und Cookies verwalten

Wenn du Cookies über mehrere Anfragen hinweg behältst, wirkt dein Scraper eher wie eine echte Nutzersitzung:

1session = requests.Session()
2# Erst die Startseite besuchen, um realistische Cookies zu erhalten
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# Dann die Zielseite scrapen
6response = session.get(target_url, headers=headers)

6. Wann du dir den Aufwand komplett sparen solltest

Wenn du keine dieser Sachen managen willst, übernimmt Thunderbits Cloud-Scraping Proxy-Rotation, Rendering und Anti-Bot-Maßnahmen transparent. Auch Scraping-APIs decken die meisten dieser Punkte standardmäßig ab. Aus meiner Erfahrung dauert das Debuggen von Anti-Ban-Problemen oft länger als das Schreiben des eigentlichen Scrapers — deshalb hat der „einfach funktioniert“-Ansatz echten ROI.

Subpage-Enrichment: Produktdetailseiten für reichere Daten scrapen

Die Best-Sellers-Listing-Seite zeigt nur Basisinfos — Titel, Preis, Bewertung, Rang. Der eigentliche Mehrwert für FBA-Recherche liegt aber auf den einzelnen Produktdetailseiten. Das fehlt dir, wenn du nur die Listing-Seite scrapen:

Das Feld „Datum der ersten Verfügbarkeit“ ist besonders wertvoll — es zeigt, wie lange ein Produkt schon am Markt ist, ein wichtiges Signal für die Wettbewerbsanalyse. Und die Anzahl der Verkäufer sowie die Buy-Box-Inhaber helfen dir einzuschätzen, ob sich eine Nische lohnt (wenn Amazon selbst mehr als 30 % Buy-Box-Anteil hält, ist der Einstieg extrem schwierig).

Python-Ansatz: Über Produkt-URLs iterieren

Nachdem du die Produkt-URLs von der Listing-Seite gesammelt hast, gehe mit einer Pause durch jede einzelne:

1for product in products:
2    time.sleep(random.uniform(3, 6))
3    detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
4    detail_soup = BeautifulSoup(detail_response.text, "html.parser")
5    # Marke extrahieren
6    brand_tag = detail_soup.find("a", id="bylineInfo")
7    product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
8    # ASIN aus Quellcode oder URL extrahieren
9    # Datum der ersten Verfügbarkeit aus der Produktdetails-Tabelle extrahieren
10    # ... weitere Felder ...

Achtung: 100 einzelne Produktseiten anzusurfen erhöht das Blockierungsrisiko deutlich. Plane Proxy-Rotation und längere Pausen ein.

Thunderbit-Ansatz: Subpage-Scraping mit einem Klick

Nachdem du die Listing-Seite in eine Tabelle gescraped hast, klicke in Thunderbit auf „Scrape Subpages“. Die KI besucht dann jede Produkt-URL 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, aber kontinuierliches Monitoring ist der eigentliche Wettbewerbsvorteil. Welche Produkte steigen und fallen, Trends früh erkennen und Preisänderungen über Wochen oder Monate verfolgen — das unterscheidet gelegentliche Recherche von datengetriebenen Entscheidungen.

Python-Ansatz: Planung mit Cron

Unter Linux/Mac kannst du dein Python-Skript mit cron planen. Hier der Crontab-Eintrag für einen täglichen Scrape um 8 Uhr morgens:

10 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:

10 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

Unter Windows nutzt du den Task Scheduler für dasselbe Ergebnis. Für eine dauerhafte Planung, ohne den Laptop laufen zu lassen, kannst du auf eine VPS oder AWS Lambda deployen — das erhöht allerdings die Infrastruktur-Komplexität.

Füge Logging und Fehlermeldungen hinzu, damit fehlgeschlagene Läufe auffallen. Nichts ist schlimmer, als zwei Wochen später zu merken, dass der Scraper stillschweigend kaputt war.

Thunderbit-Ansatz: Scheduled Scraper in natürlicher Sprache

Mit Thunderbits Scheduled Scraper kannst du das Intervall in natürlicher Sprache beschreiben — tippe „jeden Montag um 9 Uhr“ oder „jeden Tag um 8 Uhr“, und die KI interpretiert den Zeitplan. Die Scrapes laufen auf Thunderbits Cloud-Servern (kein Browser oder Computer muss laufen), und die Daten werden automatisch an Google Sheets oder Airtable exportiert. So entsteht ein Live-Monitoring-Dashboard ohne Server-Management — ideal für Operationsteams, die dauerhaft Einblick wollen, ohne DevOps-Aufwand.

Rechtliche und ethische Überlegungen beim Scraping von Amazon

Ich bin kein Anwalt, und das ist keine Rechtsberatung. Aber die rechtliche Lage in einem Scraping-Tutorial einfach zu ignorieren, wäre unverantwortlich — Nutzer in Foren sprechen das Thema Nutzungsbedingungen ausdrücklich an, und das nicht ohne 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 explizit gesperrt. Allerdings erhalten 35+ KI-spezifische User-Agents (ClaudeBot, GPTBot, Scrapy usw.) ein pauschales Disallow: /. Nur weil etwas nicht ausdrücklich verboten ist, heißt das nicht, dass Amazon Scraping gutheißt.

Amazons Nutzungsbedingungen: Amazons (aktualisiert im Mai 2025) verbieten 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 theoretisch — Amazon im November 2025 wegen unbefugtem automatisiertem Zugriff und erwirkte eine einstweilige Verfügung.

Der Präzedenzfall hiQ gegen LinkedIn: In (Ninth Circuit, 2022) entschied das Gericht, dass das Scrapen öffentlich verfügbarer Daten wahrscheinlich nicht gegen den Computer Fraud and Abuse Act verstößt. Aber hiQ einigte sich am Ende und stoppte das Scraping — ein Sieg beim CFAA schützt nicht vor Vertragsbruchklagen.

Praktische Leitlinien:

• Nur öffentlich verfügbare Daten scrapen (Preise, BSR, Produkttitel — keine PII)
• Rate Limits respektieren und Server nicht überlasten
• Daten für legitime Competitive Intelligence nutzen
• Vor Scraping in großem Maßstab eigenen Rechtsrat einholen
• Beachte, dass es inzwischen mit umfassender Datenschutzgesetzgebung gibt

Thunderbits Cloud-Scraping nutzt standardmäßige browserähnliche Anfrage-Muster, aber du solltest die Einhaltung immer mit deinem eigenen Rechtsbeistand prüfen.

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). Schwerer, 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 spricht unter 500K Anfragen pro Monat eher für APIs.
• „Ich bin kein Entwickler und brauche Daten in 2 Minuten.“ → Methode 4 (). 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 ist Folgendes hängen geblieben:

requests + BeautifulSoup ist super zum Lernen, aber das Lazy-Loading-Problem (nur etwa 30 von 50 Produkten) und die fragilen CSS-Selektoren machen es für den produktiven Einsatz unpraktisch.

Selenium löst das Lazy-Loading-Problem und erfasst alle 50 Produkte pro Seite, ist aber langsam, speicherhungrig und wird von Amazons Bot-Schutz trotzdem erkannt.

Scraping-APIs bieten die beste Zuverlässigkeit für Scraping im produktiven Betrieb — bei Amazon — aber die Kosten steigen und du musst dennoch Parsing-Code schreiben.

Thunderbit war mit Abstand der schnellste Weg bis zu den Daten. Die KI übernimmt Layout-Änderungen, Lazy Loading, Pagination und Anti-Bot-Maßnahmen ohne jede Konfiguration. Für nicht-technische Nutzer oder Teams, die wiederkehrende Daten ohne DevOps-Aufwand brauchen, ist das die praktischste Option.

Die wichtigste Lektion? Amazons Anti-Bot-Schutz und häufige Layout-Änderungen bedeuten, dass wartungsarme Lösungen auf lange Sicht am meisten Zeit sparen. Jede Stunde, die du mit kaputten Selektoren und rotierenden Proxies verbringst, fehlt dir bei der eigentlichen Analyse.

Du willst den No-Code-Weg ausprobieren? gibt dir genug Credits, um ein paar Best-Sellers-Kategorien zu scrapen und die Ergebnisse selbst zu sehen. Lieber der Python-Weg? Die obigen Codebeispiele sollten dir den Einstieg erleichtern. So oder so hast du Amazon-Bestseller-Daten dann in einer Tabelle statt vor einem Browser-Tab.

Mehr zu Web-Scraping-Ansätzen findest du in unseren Anleitungen zu , und . Außerdem kannst du Schritt-für-Schritt-Videos auf dem ansehen.

Mehr erfahren