Die besten Web-Scraping-Tools und Software im Jahr 2025

Letztes Wochenende habe ich eine ganze Kanne Kaffee durchgezogen, während ich Amazons Best-Seller-Seite auf vier verschiedene Arten extrahiert habe. Zwei Methoden liefen richtig gut, eine hätte mich fast mit einer IP-Sperre erwischt, und eine war tatsächlich nur ein einziger Klick. Hier ist alles, was ich dabei gelernt habe.

Amazon ist ein riesiger Marktplatz — 600 Millionen Produktlistings, über 310 Millionen aktive Kundenkonten und ein Best Sellers Rank (BSR)-System, das stündlich aktualisiert wird. Wenn du FBA-Produktrecherche machst, Preise im Wettbewerb analysierst oder Trends früh erkennen willst, bevor es deine Konkurrenz tut, dann sind Best-Seller-Daten pures Gold.

Aber diese Daten aus Amazon herauszubekommen und in eine Tabelle zu bringen? Genau da wird es spannend. Ich habe requests + BeautifulSoup, Selenium, eine Scraping API und Thunderbit (unseren No-Code AI Web Scraper) getestet, um herauszufinden, welche Methode wirklich liefert — und welche dich am Ende nur auf einer CAPTCHA-Seite zurücklässt.

Was sind Amazon Best Sellers eigentlich — und warum solltest du sie beachten?

Der Amazon Best Sellers Rank (BSR) ist Amazons Echtzeit-Ranking für Produkte innerhalb jeder Kategorie, basierend auf Verkaufszahlen. Stell es dir wie eine Popularitätswertung vor, die stündlich anhand aktueller und historischer Verkaufsdaten aktualisiert wird. Amazon selbst beschreibt das so:

„Die Berechnung der Amazon Best Sellers basiert auf Amazon-Verkäufen und wird stündlich aktualisiert, um aktuelle und historische Verkäufe aller auf Amazon verkauften Artikel abzubilden.“ — Amazon Seller Central

Die Best-Seller-Seite zeigt die Top 100 Produkte pro Kategorie, aufgeteilt auf zwei Seiten mit jeweils 50 Einträgen. Seite 1 enthält die Ränge #1–50, Seite 2 die Ränge #51–100. Amazon hat bestätigt, dass Seitenaufrufe und Kundenbewertungen den BSR NICHT beeinflussen — entscheidend sind ausschließlich Verkäufe.

Wer braucht diese Daten? E-Commerce-Händler auf Produktsuche für FBA, Sales-Teams für Competitive Intelligence, Operations-Teams zur Beobachtung von Preisentwicklungen und Market-Researcher, die das Wachstum von Kategorien verfolgen. Aus meiner Erfahrung landet jeder, der auf Amazon verkauft oder mit Amazon konkurriert, irgendwann bei diesen Daten in einer Tabelle.

Warum Amazon Best Sellers mit Python scrapen?

Manuelle Produktrecherche frisst Zeit. Eine McKinsey-Studie zeigt, dass Mitarbeitende pro Woche 9,3 Stunden allein mit dem Suchen und Sammeln von Informationen verbringen. Für E-Commerce-Teams bedeutet das: stundenlang durch Amazon-Seiten klicken, Produktnamen und Preise kopieren und alles in Tabellen einfügen — nur um nächste Woche wieder von vorn anzufangen.

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

Anwendungsfall	Was du bekommst	Wer davon profitiert
FBA-Produktrecherche	Produkte mit hoher Nachfrage und geringer Konkurrenz über BSR und Bewertungsanzahl erkennen	Amazon-Händler, Dropshipper
Wettbewerbsfähige Preisbeobachtung	Preisänderungen bei den Top-Produkten deiner Kategorie verfolgen	E-Commerce-Teams, Preisanalysten
Markttrend-Monitoring	Aufstrebende Kategorien und saisonale Verschiebungen erkennen	Produktmanager, Marktforscher
Lead-Generierung	Listen der meistverkauften Marken und ihrer Produktlinien aufbauen	Sales-Teams, B2B-Outreach
Wettbewerbsanalyse	Eigene Produkte mit den Kategorienführern vergleichen	Brand Manager, Strategie-Teams

Der ROI ist real: Eine Salesforce-Umfrage unter 2.700 Commerce-Profis zeigt, dass KI-Tools E-Commerce-Mitarbeitern im Schnitt 6,4 Stunden pro Woche sparen. Und Händler, die automatisiertes Preis-Tracking nutzen, gewinnen die Buy Box 67 % der Zeit statt nur 42 % bei manuellen Trackern — das entspricht einem Umsatzplus von 37 %, ausgelöst durch schnellere Reaktionen auf Preisänderungen.

4 Wege, Amazon Best Sellers mit Python zu scrapen: ein schneller Vergleich

Bevor wir in die Schritt-für-Schritt-Anleitungen einsteigen, hier der direkte Vergleich, den ich mir selbst vor dem Testen gewünscht hätte. Die Tabelle hilft dir dabei, die richtige Methode für deinen Fall auszuwählen:

Kriterium	requests + BS4	Selenium	Scraping API (z. B. Scrape.do)	Thunderbit (No-Code)
Einrichtungsaufwand	Mittel	Hoch (Driver, Browser)	Niedrig (API-Key)	Sehr niedrig (Chrome-Erweiterung)
Kommt mit Lazy Loading klar	Nein	Ja (Scroll-Simulation)	Ja (gerendertes HTML)	Ja (KI übernimmt das Rendering)
Schutz gegen Bot-Erkennung	Niedrig (IP-Sperren)	Mittel (erkennbar)	Hoch (rotierende Proxies)	Hoch (Cloud- und Browser-Modus)
Wartungsaufwand	Hoch (Selector brechen)	Hoch (Driver-Updates + Selector)	Niedrig	Sehr niedrig (KI passt sich Layout-Änderungen an)
Kosten	Kostenlos	Kostenlos	Kostenpflichtig (pro Request)	Kostenloser Tarif + bezahlte Pläne
Am besten geeignet für	Einzel-Scrapes, Lernen	JS-lastige Seiten, Login erforderlich	Skalierung / Produktion	Nicht-Techniker, schnelle Recherche, regelmäßiges Monitoring

Wenn du die Grundlagen des Python-Scrapings lernen willst, starte mit Methode 1 oder 2. Wenn du zuverlässige Ergebnisse in Produktionsqualität brauchst, nimm Methode 3. Wenn du ohne Code mit einem Klick Ergebnisse sehen 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
Du brauchst: Python 3.8+ (für Methode 1–3), den Chrome-Browser, die Thunderbit Chrome Extension (für Methode 4) und eine Amazon-Best-Sellers-Kategorie-URL als Ziel

Methode 1: Amazon Best Sellers mit requests + BeautifulSoup scrapen

Das ist der leichte, einsteigerfreundliche Ansatz — keine Browser-Automatisierung, nur HTTP-Requests und HTML-Parsing. Dabei habe ich allerdings auch am meisten über Amazons Anti-Scraping-Schutz gelernt.

Schritt 1: Umgebung einrichten

Installiere die benötigten Pakete:

pip install requests beautifulsoup4 pandas

Dann die Imports vorbereiten:

import requests
from bs4 import BeautifulSoup
import pandas as pd
import random
import time

Schritt 2: Eine Anfrage mit realistischen Headern senden

Amazon blockiert Requests, die nach Bots aussehen. Die einfachste Gegenmaßnahme ist ein User-Agent-Header, der einen echten Browser nachahmt. Hier ein Beispiel mit aktuellen, plausiblen 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)  # Sollte 200 sein

Wenn du einen 200-Statuscode siehst, bist du durch. Wenn du 503 bekommst oder auf einer CAPTCHA-Seite landest, hat Amazon deine Anfrage markiert.

Schritt 3: Produktdaten mit BeautifulSoup parsen

Untersuche das HTML der Amazon-Seite in den Browser-DevTools (Rechtsklick → Untersuchen). Die Produktcontainer verwenden die ID gridItemRoot. In jedem Container findest du 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 mit _cDEzb_ beginnenden Klassennamen sind CSS-Module-Hashes, die Amazon regelmäßig neu generiert. Die ID gridItemRoot und die Klasse a-link-normal sind etwas stabiler, aber prüfe die Selector immer mit den DevTools, bevor du den Scraper startest.

Schritt 4: Als CSV exportieren

df = pd.DataFrame(products)
df.to_csv("amazon_best_sellers.csv", index=False)
print(f"{len(products)} Produkte gescrapt")

Was du erwarten kannst — und was schiefgeht

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

Weitere Einschränkungen:

IP-Sperren greifen schnell, wenn du keine Proxy-Rotation nutzt (ich wurde nach etwa 15 schnellen Requests blockiert)
CSS-Selector brechen, sobald Amazon das Seitenlayout ändert — und das passiert regelmäßig
Keine Pagination-Unterstützung out of the box

Zum Lernen von Python-Webscraping ist der Ansatz super. Für den produktiven Einsatz ist er allerdings fragil.

Methode 2: Amazon Best Sellers mit Selenium scrapen

Selenium löst das Lazy-Loading-Problem, indem es einen echten Browser startet — aufwendiger beim Setup, dafür holt es alle 50 Produkte pro Seite.

Schritt 1: Selenium installieren

pip install selenium pandas

Gute Nachricht: Seit Selenium 4.6+ brauchst du webdriver-manager nicht mehr. Der Selenium Manager lädt die Treiber automatisch 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-Engine wie Chrome mit Oberfläche und macht es für Amazon schwerer, die Automatisierung zu erkennen.

Schritt 2: Am Lazy Loading vorbeiscrollen

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

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 erscheinen. Bei mir haben 5 Page-Downs mit 2 Sekunden Pause gereicht, je nach Verbindung kann es aber nötig sein, das anzupassen.

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 wichtig — manche Produkte sind vielleicht nicht verfügbar oder haben fehlende Felder, und du willst nicht, dass ein einzelnes fehlerhaftes Element den ganzen Scrape stoppt.

Schritt 4: Pagination behandeln

Amazon teilt 100 Best Sellers auf zwei Seiten mit unterschiedlichen URL-Strukturen auf:

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)
    # ... Produkte wie oben extrahieren ...
    all_products.extend(products)

driver.quit()

Was du erwarten kannst

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

Weitere Schwachstellen:

WebDriver-Versionen können gelegentlich dennoch nicht zusammenpassen, auch wenn der Selenium Manager das viel seltener gemacht hat
CSS-Selector müssen angepasst werden, sobald Amazon sein DOM verändert
Der Speicherverbrauch ist hoch — eine Browser-Instanz belegt schnell 200–400 MB RAM

Methode 3: Amazon Best Sellers mit einer Scraping API scrapen

Scraping APIs sind der Ansatz „lass einfach jemand anderes die schwierigen Teile übernehmen“. Dienste wie Scrape.do, Oxylabs und ScrapingBee kümmern sich um Proxy-Rotation, JavaScript-Rendering und Anti-Bot-Schutz — du sendest nur eine URL 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 Infrastruktur, rotiert Proxies, behandelt CAPTCHAs und liefert sauberes HTML zurück. Danach parsest du das HTML wie gewohnt mit BeautifulSoup.

Schritt 1: Anfrage über die API senden

Hier ein Beispiel mit Scrape.do (die Preise starten bei 29 $/Monat für 150.000 Credits; 1 Credit = 1 Request, 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 Parsing identisch zu Methode 1 — gleiche Selector, gleiche Extraktionslogik.

Realitätscheck bei den Kosten

Hier sind die gängigen API-Anbieter mit ihren Kosten pro 1.000 Amazon-Requests zum jeweils besten verfügbaren Preis:

Anbieter	Kosten pro 1.000 Requests	Hinweise
Scrape.do	ca. 0,19 $	Pauschalpreis, keine Credit-Multiplikatoren
Oxylabs	ca. 1,80 $	5x-Multiplikator für JS-Rendering
ScrapingBee	ca. 4,90 $	5–25x-Multiplikatoren für Premium-Funktionen
Bright Data	5,00 $+	Umfangreichste Daten (686 Felder/Produkt), aber am langsamsten (ca. 66 Sek./Request)

Vor- und Nachteile

Vorteile: Sehr zuverlässig (ca. 99 % Erfolgsquote auf Amazon bei den Top-Anbietern), kein Driver-Wartungsaufwand, Anti-Bot-Schutz ist automatisch, gute Skalierung.

Nachteile: Kosten pro Request steigen bei Volumen, du musst trotzdem Parsing-Code schreiben, und CSS-Änderungen können weiterhin Probleme machen. Bei 100.000 Seiten pro Monat ist der Kostenvergleich deutlich: Eigenentwicklung kostet über drei Jahre rund 1,98 Mio. $ gegenüber 332.000 $ mit einem API-Anbieter — also 71 % weniger.

Der Break-even liegt typischerweise bei 500.000 bis 1 Million Requests pro Monat. Darunter überwiegt der Zeitgewinn durch die API meist klar die Kosten.

Methode 4: Amazon Best Sellers mit Thunderbit scrapen (ohne Python)

Offen gesagt: Ich arbeite bei Thunderbit, daher solltest du diesen Abschnitt mit diesem Kontext lesen. Trotzdem habe ich alle vier Methoden direkt hintereinander getestet, und der Unterschied bei der Zeit bis zu den Daten war wirklich auffällig.

Thunderbit ist ein AI Web Scraper, der als Chrome-Erweiterung läuft. Die Grundidee: Statt CSS-Selector 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 Chrome Web Store und klicke auf „Zu Chrome hinzufügen“. Registriere dich für ein kostenloses Konto — der Gratis-Tarif enthält genug Credits zum 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 „One Click Extract“ klicken

Öffne die Thunderbit-Seitenleiste und klicke auf „One Click Extract“. Die KI analysiert die Seitenstruktur und erkennt die Spalten: Produktname, Preis, Bewertung, Bild-URL, Anbieter, Produkt-URL und Rang. In meinem Test hat sie alle relevanten Felder in etwa 3 Sekunden korrekt erkannt.

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

Schritt 4: Auf „Scrape“ klicken

Drücke 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 Tarif kostenlos — ohne versteckte Zusatzkosten.

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

Warum Thunderbit mit Amazon gut klarkommt

Weil die KI die Seite bei jedem Lauf neu liest, passt sie sich Layout-Änderungen automatisch an — keine CSS-Selector, die gepflegt werden müssen. Das löst direkt das häufigste Problem in Scraping-Foren: „Ein einfacher Webscraper reicht nicht, du brauchst für Elementänderungen ständig neue Fallbacks.“ Wenn Amazon sein DOM verändert (was regelmäßig passiert), 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 nur wollen, dass es funktioniert, entfällt damit der komplette Anti-Ban-Stress.

Spar dir die Selector-Pflege Wenn Amazon sein Markup ändert, brechen deine BeautifulSoup-Selector. Thunderbits KI liest die Seite bei jedem Lauf neu ein und erkennt die Felder erneut. Get Started Free

Das Anti-Ban-Playbook: So verhinderst du Sperren durch Amazon

Amazons Bot-Erkennung ist aggressiv. Während meiner Tests wurde meine IP zeitweise blockiert, und in Foren berichten Nutzer Ähnliches: „Überall Fehler, Amazon leitete mich sogar zur Startseite um.“ Wenn du den Python-Weg gehst (Methode 1–3), ist dieser Abschnitt entscheidend.

Hier ist eine mehrstufige Strategie, von einfach bis fortgeschritten:

1. User-Agent-Strings rotieren

Immer denselben User-Agent zu senden, ist verdächtig. Nutze den Pool mit 5+ Strings aus dem Beispiel von Methode 1 und wähle pro Request zufällig einen aus:

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

2. Zufällige Pausen zwischen Requests einbauen

Gleichmäßige Pausen sind erkennbar (Muster). Zufällige sind sicherer:

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

Ich habe festgestellt, dass 2 bis 5 Sekunden zwischen den Requests für kleinere Batches (unter 50 Requests) unauffällig genug waren. Bei größeren Läufen solltest du eher 3 bis 7 Sekunden wählen.

3. Proxy-Rotation nutzen

Das ist der wichtigste Punkt. Benchmark-Tests von Proxyway zeigen, dass Residential Proxies auf Amazon im Schnitt etwa 94 % Erfolgsrate erreichen, gegenüber nur etwa 59 % bei Datacenter-Proxies — also 35 Prozentpunkte Unterschied. Amazons Erkennung umfasst TLS-Fingerprinting, Verhaltensanalyse und Ratenbegrenzung pro IP, daher werden klassische Datacenter-IPs oft schon nach Sekunden auffällig.

Residential Proxies sind teurer (je nach Anbieter etwa 2–12 $ pro GB), aber deutlich zuverlässiger. Ein Code-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 den navigator.webdriver-Flag entfernen
driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
})

5. Sessions und Cookies verwalten

Wenn du Cookies über Requests hinweg behältst, wirkt dein Scraper mehr wie eine echte Benutzersitzung:

session = requests.Session()
# Zuerst 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

Wenn du all das nicht managen willst, übernimmt Thunderbits Cloud-Scraping Proxy-Rotation, Rendering und Anti-Bot-Maßnahmen transparent im Hintergrund. Auch Scraping APIs decken die meisten dieser Themen bereits ab Werk ab. Aus meiner Erfahrung kostet das Debuggen von Anti-Ban-Problemen oft mehr Zeit als das eigentliche Schreiben des Scrapers — der „einfach funktioniert“-Ansatz hat also echten ROI.

Subpage-Anreicherung: Produktdetailseiten für mehr Daten scrapen

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

Feld	Listing-Seite	Produktdetailseite
Produktname	✅	✅
Preis	✅	✅
Bewertung	✅	✅
BSR-Rang	✅	✅ (inkl. Unterkategorien-Ränge)
Marke	❌	✅
ASIN	❌	✅
Datum der ersten Verfügbarkeit	❌	✅
Maße/Gewicht	❌	✅
Anzahl der Verkäufer	❌	✅
Bullet-Point-Features	❌	✅
Buy-Box-Eigentümer	❌	✅

Das Feld „Datum der ersten Verfügbarkeit“ ist besonders wertvoll — es zeigt dir, wie lange ein Produkt schon auf dem Markt ist, ein wichtiger Hinweis für die Wettbewerbsanalyse. Und die Anzahl der Verkäufer plus der Buy-Box-Eigentümer helfen dir einzuschätzen, ob sich eine Produktnische überhaupt lohnt (wenn Amazon selbst über 30 % Buy-Box-Anteil hält, ist der Wettbewerb extrem hart).

Python-Ansatz: Über Produkt-URLs iterieren

Nachdem du die Produkt-URLs von der Listing-Seite gesammelt hast, gehst du 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 dem Seitenquelltext oder der URL extrahieren
    # Datum der ersten Verfügbarkeit aus der Produktdetails-Tabelle extrahieren
    # ... weitere Felder ...

Kleine Warnung: Wenn du 100 einzelne Produktseiten aufrufst, steigt dein Sperr-Risiko deutlich. Plane also unbedingt Proxy-Rotation und längere Pausen ein.

Thunderbit-Ansatz: Subpage-Scraping mit einem Klick

Nachdem du die Listing-Seite in eine Tabelle gescrapt hast, klickst du in Thunderbit auf „Scrape Subpages“. Die KI besucht dann jede Produkt-URL und reichert die Tabelle automatisch mit zusätzlichen Spalten an — Marke, ASIN, Spezifikationen, Features und mehr. Kein weiterer Code, keine Selector, kein Setup. Das ist besonders nützlich für E-Commerce-Teams, die ein vollständiges Bild für Sourcing-Entscheidungen brauchen, aber keinen Detailseiten-Parser schreiben und pflegen möchten.

Wiederkehrende Scrapes automatisieren: Best Sellers über die Zeit beobachten

Ein einmaliger Scrape ist nützlich, aber das eigentliche Potenzial liegt im laufenden Monitoring. Zu sehen, welche Produkte steigen oder fallen, Trends früh zu erkennen und Preisänderungen über Wochen oder Monate zu verfolgen — genau das trennt gelegentliche Recherche von datengetriebener Entscheidungsfindung.

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:

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 nutzt du den Task Scheduler für denselben Zweck. Wenn die Planung dauerhaft laufen soll, ohne dass dein Laptop eingeschaltet bleibt, kannst du auf einen VPS oder AWS Lambda deployen — allerdings steigt damit die Infrastruktur-Komplexität.

Füge Logging und Fehlerbenachrichtigungen hinzu, um fehlgeschlagene Läufe zu erkennen. Nichts ist ärgerlicher, als zwei Wochen später festzustellen, dass dein Scraper still und leise kaputtgegangen ist.

Thunderbit-Ansatz: Scheduled Scraper in natürlicher Sprache

Thunderbits Scheduled Scraper lässt dich 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 eingeschaltet sein), und die Daten exportieren automatisch nach Google Sheets oder Airtable. So entsteht ein Live-Monitoring-Dashboard ohne Server-Management — ideal für Operations-Teams, die laufende Transparenz wollen, ohne DevOps-Aufwand.

Rechtliche und ethische Aspekte beim Scrapen von Amazon

Ich bin kein Anwalt, und das ist keine Rechtsberatung. Aber die rechtliche Lage in einem Scraping-Tutorial zu ignorieren wäre unverantwortlich — Foren-Nutzer sprechen ToS-Fragen ausdrücklich an, und das aus gutem Grund.

Amazons robots.txt: Im Jahr 2026 enthält Amazons robots.txt über 80 spezifische Disallow-Pfade, aber /gp/bestsellers/ ist für normale User-Agents NICHT ausdrücklich blockiert. Allerdings erhalten mehr als 35 KI-spezifische User-Agents (ClaudeBot, GPTBot, Scrapy usw.) ein pauschales Disallow: /. Die Tatsache, dass ein Pfad nicht gesperrt ist, bedeutet nicht, dass Amazon Scraping billigt.

Amazons Nutzungsbedingungen: Amazons Conditions of Use (aktualisiert im Mai 2025) verbieten ausdrücklich, „jedes automatisierte Verfahren oder jede Technologie zu verwenden, um auf Teile der Amazon-Website zuzugreifen, sie zu erfassen, zu kopieren oder zu überwachen“, sofern keine schriftliche Erlaubnis vorliegt. Das ist keine Theorie — Amazon hat im November 2025 gegen Perplexity AI wegen unautorisierter automatisierter Zugriffe geklagt und eine einstweilige Verfügung erhalten.

Der hiQ-vs.-LinkedIn-Präzedenzfall: In hiQ Labs v. LinkedIn (Ninth Circuit, 2022) entschied das Gericht, dass das Scrapen öffentlich zugänglicher Daten wahrscheinlich nicht gegen den Computer Fraud and Abuse Act verstößt. Aber hiQ hat sich am Ende dennoch geeinigt, das Scraping einzustellen — ein Sieg unter dem CFAA schützt nicht vor Vertragsverletzungsklagen.

Praktische Leitlinien:

Nur öffentlich zugängliche 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 größerem Umfang eigenen Rechtsbeistand einholen
Beachten, dass inzwischen über 20 US-Bundesstaaten umfassende Datenschutzgesetze haben

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

Dafür brauchst du kein Python Wenn das Ziel eine Tabelle und keine Pipeline ist, bringt dich ein Klick ans Ziel. Export direkt nach Excel, Google Sheets, Airtable oder Notion. Get Started Free

Welche Methode solltest du wählen? Eine kurze Entscheidungshilfe

Die Kurzfassung:

„Ich lerne Python und will ein Wochenendprojekt.“ → Methode 1 (requests + BeautifulSoup). Du lernst dabei viel über HTTP-Requests, HTML-Parsing und Amazons Bot-Schutz.
„Ich muss JavaScript-lastige Seiten oder eingeloggte Sessions scrapen.“ → Methode 2 (Selenium). Schwerer, aber gut für dynamische Inhalte.
„Ich betreibe Scrapes in Produktionsgröße.“ → Methode 3 (Scraping API). Lass Proxies und Rendering von jemand anderem verwalten. Der Total Cost of Ownership spricht unter 500K Requests/Monat klar für APIs.
„Ich bin kein Entwickler und will Daten in 2 Minuten.“ → Methode 4 (Thunderbit). Kein Code, keine Selector, keine Wartung.
„Ich brauche laufendes Monitoring ohne Serververwaltung.“ → Thunderbit Scheduled Scraper. Einrichten und vergessen.

Thunderbit für Amazon Best Sellers ausprobieren Get Started Free

Fazit und wichtigste Erkenntnisse

Nach einem Wochenende Testen ist das bei mir hängen geblieben:

requests + BeautifulSoup ist super zum Lernen, aber das Lazy Loading (nur rund 30 von 50 Produkten) und die fragilen CSS-Selector 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 trotzdem für Amazons Bot-Schutz erkennbar.

Scraping APIs bieten für Scraping in Produktionsgröße die beste Zuverlässigkeit — ca. 99 % Erfolgsrate auf Amazon — aber die Kosten steigen, und du musst weiterhin Parsing-Code schreiben.

Thunderbit hat mit Abstand die schnellste Zeit bis zu den Daten geliefert. Die KI übernimmt Layout-Änderungen, Lazy Loading, Pagination und Anti-Bot-Maßnahmen ohne Konfiguration. Für nicht-technische Nutzer oder Teams, die regelmäßig Daten brauchen, ohne DevOps-Aufwand zu haben, ist das die praktischste Lösung.

Die wichtigste Lektion? Amazons Anti-Bot-Schutz und die häufigen Layout-Änderungen bedeuten, dass wartungsfreie Lösungen auf lange Sicht die meiste Zeit sparen. Jede Stunde, die du mit kaputten Selector und rotierenden Proxies verbringst, fehlt dir für die eigentliche Analyse.

Willst du die No-Code-Variante testen? Der kostenlose Tarif von Thunderbit gibt dir genug Credits, um ein paar Best-Sellers-Kategorien zu scrapen und die Ergebnisse selbst zu sehen. Lieber Python? Die obigen Code-Beispiele sollten dir den Einstieg erleichtern. Auf jeden Fall hast du Amazon-Best-Seller-Daten am Ende in einer Tabelle statt vor einem Browser-Tab zu sitzen.

Mehr zu Web-Scraping-Ansätzen findest du in unseren Leitfäden zu Amazon-Produkten und Bewertungen scrapen, Daten von Websites nach Excel extrahieren und den besten AI Web Scrapern. Außerdem kannst du auf dem Thunderbit YouTube-Kanal Schritt-für-Schritt-Anleitungen ansehen.

Mehr erfahren

Von der Webseite zur Tabelle

Beschreibe einfach, was du brauchst — Thunderbits KI-Agent erfasst es und exportiert es nach Excel, Google Sheets, Airtable oder Notion. Kostenlos loslegen.

Chrome Store Rating

PRODUCT HUNT#1 Product of the Week

Amazon Best Sellers mit Python scrapen: 4 Methoden im Praxistest