Du hast schon ein Amazon-Scraping-Tutorial nachgebaut und bist dann an CAPTCHAs, 503-Fehlern oder gähnend leeren Ergebnissen hängengeblieben? Damit bist du nicht allein. Ein Großteil der Python-Guides zum Amazon-Scraping, die online kursieren, ist 2022 oder 2023 entstanden und stützt sich auf Selektoren und Methoden, die Amazon längst dichtgemacht hat.
Ich baue bei Thunderbit seit Jahren an Tools zur Datenextraktion, und aus der Praxis lässt sich eines festhalten: Amazon zählt zu den zähesten Websites, wenn es um verlässliches Scraping geht. Das HTML wandert ständig, eine sechsstufige Anti-Bot-Abwehr läuft im Hintergrund, und über A/B-Tests sieht nicht einmal jeder Nutzer dasselbe Seitenlayout. In diesem Leitfaden baue ich mit dir einen Python-Amazon-Scraper, der 2025 tatsächlich läuft – mit verifizierten CSS-Selektoren, einer mehrstufigen Anti-Blocking-Strategie und Hinweisen zu Scheduling und Export, die in fast jedem Tutorial fehlen. Und wer die Daten einfach nur braucht, ohne sich mit Python zu plagen, sieht außerdem, wie Thunderbit dieselbe Aufgabe in etwa zwei Klicks abhakt.
Was ist Amazon-Produktscraping?
Amazon-Produktscraping meint das automatisierte Auslesen öffentlich verfügbarer Daten – Produktnamen, Preise, Bewertungen, Anzahl der Rezensionen, Bilder, Verfügbarkeit und mehr – von Amazon-Produktseiten und Suchergebnisseiten. Statt Infos aus hunderten Angeboten von Hand zu kopieren, ruft ein Scraper jede Seite auf, liest das HTML aus und packt die gewünschten Daten in ein strukturiertes Format wie CSV, Excel oder eine Datenbank.
Stell dir einen unermüdlichen Praktikanten vor, der in der Zeit, die du für deinen ersten Kaffee brauchst, tausend Produktseiten durcharbeitet. Nur vertippt sich dieser Praktikant nie und kennt keine Mittagspause.
Warum Amazon-Produkte mit Python scrapen?
Auf Amazon liegen grob 350 bis 600 Millionen Produktangebote in mehr als 30 Kategorien, getragen von rund 9,7 Millionen Verkäuferkonten. Drittanbieter stehen inzwischen für 69 % des gesamten GMV. Auch nur einen Bruchteil dieses Katalogs von Hand zu überwachen, ist schlicht aussichtslos. Deshalb scrapen Teams Amazon:
| Anwendungsfall | Wer davon profitiert | Welche Daten extrahiert werden |
|---|---|---|
| Preisüberwachung & Repricing | E-Commerce-Teams, Marketplace-Seller | Preise, Verfügbarkeit, Verkäuferinfos |
| Wettbewerbsanalyse | Produktmanager, Brand-Teams | Produktmerkmale, Bewertungen, Rezensionen |
| Marktanalyse | Analysten, Teams für neue Produkte | Kategorietrends, Preisverteilungen |
| Lead-Generierung | Vertriebsteams | Verkäufernamen, Markeninfos, Kontaktdaten |
| Affiliate-Marketing | Content-Creator, Deal-Websites | Preise, Angebote, Produktdetails |
| Bestandsüberwachung | Supply Chain, Beschaffung | Lagerstatus, Lieferprognosen |
Allein die Dynamik der Amazon-Preise macht Automatisierung alternativlos: Amazon ändert Preise mehr als 2,5 Millionen Mal pro Tag, und der Preis eines durchschnittlichen Produkts aktualisiert sich etwa alle 10 Minuten. Zum Vergleich: Wettbewerber wie Best Buy und Walmart bewegen ihre Preise nur rund 50.000 Mal pro Monat. Da kommt kein menschliches Team hinterher.
Mit Python hast du den Scraping-Prozess komplett in der Hand – du entscheidest, was extrahiert wird, wie Fehler abgefangen werden und wo die Daten landen. Im Gegenzug liegt aber auch die Verantwortung für Wartung, Anti-Blocking und Amazons fortlaufende HTML-Änderungen bei dir.
Was du von Amazon scrapen kannst — und was nicht
Von öffentlich zugänglichen Produktseiten lassen sich in der Regel diese Daten herausziehen:
- Produkttitel (Name, Marke)
- Preis (aktueller Preis, Originalpreis, Aktionspreis)
- Bewertung (durchschnittliche Sternebewertung)
- Anzahl der Rezensionen
- Produktbilder (URL des Hauptbilds)
- Verfügbarkeit / Lagerstatus
- ASIN (Amazon Standard Identification Number)
- Produktbeschreibung und Stichpunkte
- Verkäuferinformationen
- Produktvarianten (Größe, Farbe usw.)
Davon solltest du die Finger lassen:
- Daten hinter Login-Schranken: erweiterte Bewertungsseiten, persönliche Kontodaten, Bestellhistorie
- Personenbezogene Daten: Namen von Käufern, Adressen, Zahlungsinformationen
- Urheberrechtlich geschützte Inhalte zur Weiterveröffentlichung: Produktbeschreibungen und Bilder taugen für Analysen, aber gib sie nicht als deine eigenen aus
Die robots.txt von Amazon sperrt über 50 bekannte Bots aus (darunter GPTBot, Scrapy und ClaudeBot) und verriegelt Pfade wie Benutzerkonten, Warenkörbe und Wunschlisten. Produktdetailseiten sind nicht ausdrücklich gesperrt, doch die Nutzungsbedingungen von Amazon untersagen automatisierten Zugriff trotzdem. Gerichte trennen dabei meist zwischen Verstößen gegen die AGB (zivilrechtlich) und strafrechtlichen Verstößen nach dem CFAA – zur Rechtslage mehr am Ende des Leitfadens.
Welche Tools und Libraries du brauchst
Das ist das Python-Setup für dieses Tutorial:
| Library | Zweck | Warum wir sie nutzen |
|---|---|---|
requests | HTTP-Anfragen | Einfach, weit verbreitet unterstützt |
beautifulsoup4 | HTML-Parsing | Leichte Extraktion per CSS-Selektor |
lxml | Schneller HTML-Parser | Wird als Parser-Backend für BeautifulSoup genutzt |
curl_cffi | TLS-Fingerprint-Imitation | Entscheidend, um Amazons Erkennung zu umgehen |
pandas | Datenstrukturierung & Export | DataFrames, CSV-/Excel-Export |
Optional (für Inhalte, die per JavaScript gerendert werden):
seleniumoderplaywright— Headless-Browser-Automatisierung
Deine Python-Umgebung einrichten
Öffne dein Terminal und führe Folgendes aus:
mkdir amazon-scraper && cd amazon-scraper
python -m venv venv
source venv/bin/activate # Unter Windows: venv\Scripts\activate
pip install requests beautifulsoup4 lxml curl_cffi pandas
Prüfe danach, ob alles sauber installiert ist:
import requests, bs4, curl_cffi, pandas
print("Alles gut!")
Erscheint „Alles gut!“ ohne Fehler, kann es losgehen.
Warum die meisten Amazon-Scraping-Tutorials kaputtgehen — und warum dieses anders ist
Das ist der Teil, den die meisten Guides auslassen – und vermutlich genau der Grund, warum du gerade hier bist.
Amazon krempelt seine HTML-Struktur, Klassennamen und Element-IDs regelmäßig um. In der Scraping-Community ist es kein Geheimnis, dass 10–15 % der Crawler wöchentlich nachjustiert werden müssen, weil sich das DOM verschiebt und Fingerprinting-Methoden wechseln. Der berühmteste Ausfall? Der Selektor #priceblock_ourprice, der von 2018 bis 2023 in hunderten Tutorials auftauchte. Diese ID existiert auf Amazon-Produktseiten schon lange nicht mehr.
Ein schneller Abgleich – was kaputt ist und was heute trägt:
| Datenpunkt | Kaputter Selektor (vor 2024) | Funktionierender Selektor 2025 |
|---|---|---|
| Preis | #priceblock_ourprice | div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen |
| Titel | #productTitle | span#productTitle (funktioniert weiterhin) |
| Bewertung | span.a-icon-alt (manchmal falscher Kontext) | #acrPopover span.a-icon-alt |
| Anzahl der Rezensionen | #acrCustomerReviewCount | span#acrCustomerReviewText |
| Verfügbarkeit | #availability span | div#availability span.a-size-medium |
Jeder Codeausschnitt in diesem Leitfaden wurde 2025 gegen echte Amazon-Seiten geprüft. Du bekommst die tatsächlichen CSS-Selektoren samt erwarteter Ausgabe – nichts kopiert aus dem Jahr 2022.
Bevor du startest
- Schwierigkeitsgrad: Mittelstufe (grundlegende Python-Kenntnisse vorausgesetzt)
- Benötigte Zeit: ca. 30–45 Minuten für das komplette Tutorial; ca. 10 Minuten für den Basis-Scraper
- Was du brauchst: Python 3.9+, Chrome-Browser (zum Prüfen von Amazon-Seiten), ein Terminal und optional die Thunderbit Chrome-Erweiterung, falls du den No-Code-Ansatz vergleichen möchtest
Schritt 1: Deine erste Anfrage an Amazon senden
Öffne eine beliebige Amazon-Produktseite im Browser und kopiere die URL. Wir starten mit einem schlichten requests.get():
import requests
url = "https://www.amazon.com/dp/B0DGNFM9YJ"
response = requests.get(url)
print(response.status_code)
print(response.text[:500])
Lässt du das laufen, fängst du dir mit hoher Wahrscheinlichkeit einen 503-Statuscode oder eine Seite mit dem Hinweis „To discuss automated access to Amazon data please contact…“ ein. Das ist Amazons WAF (Web Application Firewall), die dein Python-Skript enttarnt hat. Ein nacktes requests.get() ohne passende Header kommt gegen Amazon nur auf etwa 2 % Erfolgsquote.
Du siehst also vermutlich 503 und eine Blockseite im HTML. Alles normal – das beheben wir im nächsten Schritt.
Schritt 2: Eigene Header und TLS-Imitation einrichten
Bloß einen User-Agent zu setzen, reicht heute nicht mehr. Amazon gleicht deine HTTP-Header mit deinem TLS-Fingerprint ab. Behauptest du, Chrome 120 zu sein, während der TLS-Handshake die Python-requests-Bibliothek verrät, fliegst du sofort auf.
Der verlässlichste Weg im Jahr 2025 ist curl_cffi mit Browser-Imitation:
from curl_cffi import requests as cfreq
headers = {
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Referer": "https://www.google.com/",
"DNT": "1",
"Connection": "keep-alive",
"Upgrade-Insecure-Requests": "1",
}
url = "https://www.amazon.com/dp/B0DGNFM9YJ"
response = cfreq.get(url, headers=headers, impersonate="chrome124")
print(response.status_code)
print(len(response.text))
Mit curl_cffi und der Imitation von Chrome 124 klettern die Erfolgsraten auf etwa 94 % – also das 47-Fache von einfachem requests. Du solltest jetzt einen 200-Statuscode und eine deutlich längere HTML-Antwort sehen (100.000+ Zeichen).
Falls trotzdem ein 503 kommt, probier einen anderen impersonate-Wert (z. B. "chrome131") oder leg vor dem nächsten Versuch eine kurze Pause ein.
Schritt 3: HTML parsen und Produktdaten extrahieren
Jetzt, wo das vollständige HTML vorliegt, holen wir die Daten mit BeautifulSoup und den für 2025 verifizierten Selektoren heraus:
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "lxml")
# Produkttitel
title_el = soup.select_one("span#productTitle")
title = title_el.get_text(strip=True) if title_el else None
# Preis
price_el = soup.select_one(
"div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
)
if not price_el:
price_el = soup.select_one("span.priceToPay .a-offscreen")
if not price_el:
price_el = soup.select_one(".apexPriceToPay .a-offscreen")
price = price_el.get_text(strip=True) if price_el else None
# Bewertung
rating_el = soup.select_one("#acrPopover span.a-icon-alt")
rating = rating_el.get_text(strip=True) if rating_el else None
# Anzahl der Rezensionen
reviews_el = soup.select_one("span#acrCustomerReviewText")
reviews = reviews_el.get_text(strip=True) if reviews_el else None
# Verfügbarkeit
avail_el = soup.select_one("div#availability span")
availability = avail_el.get_text(strip=True) if avail_el else None
# URL des Hauptbilds
img_el = soup.select_one("#landingImage")
image_url = img_el.get("src") if img_el else None
print(f"Titel: {title}")
print(f"Preis: {price}")
print(f"Bewertung: {rating}")
print(f"Rezensionen: {reviews}")
print(f"Verfügbarkeit: {availability}")
print(f"Bild: {image_url}")
Beispielausgabe:
Titel: Apple AirPods Pro (2. Generation) mit USB-C
Preis: $189.99
Bewertung: 4.7 von 5 Sternen
Rezensionen: 98,432 Bewertungen
Verfügbarkeit: Auf Lager
Bild: https://m.media-amazon.com/images/I/61SUj2...
Beachte die mehreren Fallback-Selektoren beim Preis – Amazon nutzt je nach Produkttyp, Angebotsstatus und A/B-Test verschiedene Container. Sicherst du jede Extraktion mit einer Bedingung ab, kippt dein Scraper nicht, sobald ein Selektor mal kein Match liefert.
Schritt 4: Mehrere Produkte aus den Suchergebnissen scrapen
Wenn du einen echten Datensatz aufbauen willst, fängst du am besten bei einer Amazon-Suchergebnisseite an, sammelst ASINs und scrapst danach jede Produktdetailseite.
import time
import random
def get_search_asins(keyword, max_pages=1):
"""ASINs aus den Amazon-Suchergebnissen sammeln."""
asins = []
for page in range(1, max_pages + 1):
search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
if resp.status_code != 200:
print(f"Suchseite {page} lieferte {resp.status_code}")
break
search_soup = BeautifulSoup(resp.text, "lxml")
results = search_soup.select('div[data-component-type="s-search-result"]')
for r in results:
asin = r.get("data-asin")
if asin:
asins.append(asin)
print(f"Seite {page}: {len(results)} Produkte gefunden")
time.sleep(random.uniform(2, 5)) # Höfliche Pause
return asins
asins = get_search_asins("wireless+earbuds", max_pages=2)
print(f"{len(asins)} ASINs gesammelt")
Jede ASIN lässt sich auf eine saubere Produkt-URL abbilden: https://www.amazon.com/dp/{ASIN}. Das ist robuster als die vollständigen Suchresultat-URLs, die oft sitzungsspezifische Parameter mitschleppen.
Schritt 5: Pagination behandeln und im großen Stil scrapen
Jetzt fügen wir Suchsammlung und Detailseiten-Scraping zu einer durchgängigen Pipeline zusammen:
import pandas as pd
def scrape_product(asin):
"""Eine einzelne Amazon-Produktdetailseite scrapen."""
url = f"https://www.amazon.com/dp/{asin}"
try:
resp = cfreq.get(url, headers=headers, impersonate="chrome124")
if resp.status_code != 200:
return None
soup = BeautifulSoup(resp.text, "lxml")
title_el = soup.select_one("span#productTitle")
price_el = (
soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
or soup.select_one("span.priceToPay .a-offscreen")
or soup.select_one(".apexPriceToPay .a-offscreen")
)
rating_el = soup.select_one("#acrPopover span.a-icon-alt")
reviews_el = soup.select_one("span#acrCustomerReviewText")
avail_el = soup.select_one("div#availability span")
img_el = soup.select_one("#landingImage")
return {
"asin": asin,
"title": title_el.get_text(strip=True) if title_el else None,
"price": price_el.get_text(strip=True) if price_el else None,
"rating": rating_el.get_text(strip=True) if rating_el else None,
"reviews": reviews_el.get_text(strip=True) if reviews_el else None,
"availability": avail_el.get_text(strip=True) if avail_el else None,
"image_url": img_el.get("src") if img_el else None,
"url": url,
}
except Exception as e:
print(f"Fehler beim Scrapen von {asin}: {e}")
return None
# Alle gesammelten ASINs scrapen
products = []
for i, asin in enumerate(asins):
print(f"Scrape {i+1}/{len(asins)}: {asin}")
product = scrape_product(asin)
if product:
products.append(product)
time.sleep(random.uniform(2, 5)) # Zufällige Pause zwischen den Requests
df = pd.DataFrame(products)
print(f"\n{len(df)} Produkte erfolgreich gescrapt")
print(df.head())
Die zufällige Pause von 2 bis 5 Sekunden ist hier entscheidend. Perfekt gleichmäßige Intervalle (z. B. immer exakt 3 Sekunden) kommen Amazons Verhaltensanalyse verdächtig vor. Zufällige Abstände sehen eher nach menschlichem Browsing aus.
Schritt 6: Amazon-Daten als CSV speichern
df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
print("Gespeichert in amazon_products.csv")
Jetzt hast du eine saubere CSV mit Spalten für ASIN, Titel, Preis, Bewertung, Rezensionen, Verfügbarkeit, Bild-URL und Produkt-URL. An diesem Punkt enden die meisten Tutorials – doch wenn du einen echten Workflow aufziehst, ist CSV erst der Anfang.
Deep Dive Anti-Blocking: So hältst du deinen Scraper am Laufen
Blockiert zu werden, ist der größte Schmerzpunkt für alle, die Amazon-Produkte mit Python scrapen wollen. Amazons sechsstufige Abwehr umfasst IP-Reputationsanalyse, TLS-Fingerprinting, Prüfungen der Browser-Umgebung, Verhaltensbiometrie, CAPTCHAs und ML-basierte Anomalieerkennung. Unten findest du für jede dieser Ebenen eine passende Strategie.
User-Agents und vollständige Header rotieren
Ein einzelner statischer User-Agent fliegt schnell auf. Wechsle zwischen aktuellen Browser-Strings:
import random
USER_AGENTS = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
]
def get_headers():
return {
"User-Agent": random.choice(USER_AGENTS),
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Referer": "https://www.google.com/",
"DNT": "1",
"Connection": "keep-alive",
}
Ein Detail, das viele übersehen: Dein Accept-Language sollte zur geografischen Lage deiner IP passen. Accept-Language: en-US von einer deutschen IP ist ein Warnsignal.
TLS-Fingerprint-Imitation mit curl_cffi
Das kam in Schritt 2 schon vor, aber es ist wichtig genug für eine Wiederholung: Diese eine Technik bringt den größten Sprung bei der Erfolgsrate. Standard-Python-requests schafft bei Amazon etwa 2 % Erfolg. Mit curl_cffi und Imitation sind es rund 94 %. Das ist der Unterschied zwischen einem funktionierenden und einem kaputten Scraper.
from curl_cffi import requests as cfreq
# Auch die Imitationsziele rotieren
BROWSERS = ["chrome120", "chrome124", "chrome131"]
response = cfreq.get(
url,
headers=get_headers(),
impersonate=random.choice(BROWSERS),
)
Proxy-Rotation
Sobald du mehr als ein paar Seiten scrapen willst, führt an Proxy-Rotation kein Weg vorbei. Amazon verfolgt IP-Adressen und sperrt jede einzelne IP, die zu viele Requests abfeuert.
PROXIES = [
"http://user:pass@proxy1.example.com:8080",
"http://user:pass@proxy2.example.com:8080",
"http://user:pass@proxy3.example.com:8080",
]
proxy = random.choice(PROXIES)
response = cfreq.get(
url,
headers=get_headers(),
impersonate="chrome124",
proxies={"http": proxy, "https": proxy},
)
Residential-Proxies wirken besser als Rechenzentrums-Proxies (Amazon sperrt Rechenzentrumsbereiche proaktiv), kosten dafür aber mehr. Für ein kleines Projekt kannst du mit einem kostenpflichtigen Proxy-Dienst starten und bei Bedarf hochskalieren.
Rate Limiting und exponentielles Backoff
Keiner der Konkurrenzartikel, die mir untergekommen sind, behandelt das sauber, dabei ist es entscheidend. Bekommst du eine 503- oder CAPTCHA-Antwort, versuch es nicht sofort erneut – das ist der direkte Weg in die dauerhafte Sperre.
import time
import random
def fetch_with_backoff(url, max_retries=3):
"""Eine URL mit exponentiellem Backoff bei Fehlern abrufen."""
for attempt in range(max_retries):
response = cfreq.get(
url,
headers=get_headers(),
impersonate=random.choice(BROWSERS),
)
if response.status_code == 200:
return response
# Exponentielles Backoff mit Jitter
wait = min(2 ** attempt + random.uniform(0, 1), 30)
print(f"Versuch {attempt+1} fehlgeschlagen ({response.status_code}). Warte {wait:.1f}s...")
time.sleep(wait)
return None # Alle Wiederholungen ausgeschöpft
Die Formel wait = min(2^attempt + jitter, max_delay) lässt deine Pausen anwachsen (2 s, 4 s, 8 s …), ohne dass sie je unsinnig lang werden. Der zufällige Jitter sorgt zusätzlich dafür, dass dein Retry-Muster nicht erkennbar wird.
Selenium- oder Playwright-Fallback für JS-gerenderte Inhalte
Manche Amazon-Seiten – vor allem mit dynamischen Preis-Widgets oder Varianten-Auswahl – brauchen JavaScript, um vollständig zu rendern. Liefert curl_cffi nur lückenhaftes HTML, ist ein Headless-Browser dein Rettungsanker:
from playwright.sync_api import sync_playwright
def scrape_with_browser(url):
with sync_playwright() as p:
browser = p.chromium.launch(headless=True)
page = browser.new_page()
page.goto(url, wait_until="domcontentloaded")
page.wait_for_timeout(3000) # JS rendern lassen
html = page.content()
browser.close()
return html
Das ist langsamer – 3 bis 5 Sekunden pro Seite statt unter 1 Sekunde mit curl_cffi. Setz es nur ein, wenn es wirklich nötig ist.
Meine Erfahrung: curl_cffi schafft über 90 % der Amazon-Produktseiten ganz ohne Browser.
Anti-Blocking-Zusammenfassung
| Technik | Schwierigkeit | Wirksamkeit | In den meisten Tutorials behandelt? |
|---|---|---|---|
| Benutzerdefinierter User-Agent | Einfach | Niedrig (Amazon erkennt Muster) | Ja |
| Vollständige Header-Rotation | Einfach | Mittel | Selten |
| TLS-Imitation (curl_cffi) | Mittel | Hoch (~94 % Erfolg) | Fast nie |
| Proxy-Rotation | Mittel | Hoch | Wenn überhaupt nur kurz |
| Rate Limiting + exponentielles Backoff | Einfach | Mittel | Nein |
| Selenium-/Playwright-Fallback | Mittel | Hoch (für JS-Inhalte) | Erwähnt, aber nicht demonstriert |
Mehr als CSV: Amazon-Daten nach Google Sheets, Airtable und mehr exportieren
Jedes Tutorial, das ich mir angesehen habe, hört beim CSV-Export auf. In echten Geschäftsprozessen müssen die Daten aber in Google Sheets, Datenbanken oder Tools wie Airtable und Notion ankommen.
Mit gspread nach Google Sheets exportieren
Richte zuerst ein Google-Service-Account ein (einmaliger Aufwand):
- Öffne die Google Cloud Console → APIs & Services → Credentials
- Erstelle einen Service-Account und lade die JSON-Key-Datei herunter
- Speichere sie unter
~/.config/gspread/service_account.json - Teile dein Ziel-Spreadsheet mit der
client_emailaus der JSON-Datei
Dann:
import gspread
from gspread_dataframe import set_with_dataframe
gc = gspread.service_account()
sh = gc.open("Amazon Scrape Data")
worksheet = sh.sheet1
set_with_dataframe(worksheet, df)
print("Daten wurden nach Google Sheets exportiert!")
Damit schreibst du dein gesamtes DataFrame direkt in ein Google Sheet – live, teilbar und dashboard-ready.
Für lokale Analysen in SQLite speichern
Für größere Datensätze oder historische Auswertungen ist SQLite ideal – kein Server nötig, nur eine einzige Datei:
import sqlite3
conn = sqlite3.connect("amazon_products.db")
df.to_sql("products", conn, if_exists="append", index=False)
print(f"{len(df)} Produkte in SQLite gespeichert")
# Später abfragen:
historical = pd.read_sql_query(
"SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
conn,
)
Die No-Code-Alternative
Wenn du keine Lust auf gepflegte Python-Exportskripte hast, bietet Thunderbit kostenlosen Export nach Google Sheets, Airtable, Notion, Excel, CSV und JSON – inklusive Bildfeldern, die direkt in Airtable und Notion gerendert werden. Kein gspread-Setup, keine API-Credentials, überhaupt kein Code. Für Teams, die Daten direkt in ihre vorhandenen Tools fließen lassen wollen, ist das eine enorme Zeitersparnis.
Automatisierte Amazon-Scrapes planen — das fehlende Kapitel
Preisüberwachung und Bestandskontrolle leben von wiederkehrenden Scrapes, nicht von Einmal-Läufen. Trotzdem ist mir kein einziger Konkurrenzartikel begegnet, der Scheduling abdeckt. So automatisierst du deinen Python-Scraper.
Cron-Jobs (Linux/macOS)
Öffne dein Crontab:
crontab -e
Füge eine Zeile hinzu, damit dein Scraper täglich um 6 Uhr morgens läuft:
0 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1
Oder alle 6 Stunden:
0 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1
Windows Aufgabenplanung
Erstelle eine Batch-Datei run_scraper.bat:
@echo off
cd /d "C:\path\to\amazon-scraper"
call venv\Scripts\activate
python scraper.py
deactivate
Öffne dann die Aufgabenplanung → Einfache Aufgabe erstellen → Trigger festlegen (täglich, stündlich) → Aktion: „Programm starten“ → zu run_scraper.bat navigieren.
GitHub Actions (kostenlose Stufe)
Für einen Cloud-Plan ohne eigene Infrastruktur:
name: Amazon Scraper
on:
schedule:
- cron: "0 6 * * *" # Täglich um 6 Uhr UTC
workflow_dispatch: # Manueller Start
jobs:
scrape:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Python einrichten
uses: actions/setup-python@v4
with:
python-version: "3.11"
- name: Abhängigkeiten installieren
run: pip install -r requirements.txt
- name: Scraper ausführen
run: python scraper.py
- name: Ergebnisse committen
run: |
git config user.name 'GitHub Actions'
git config user.email 'actions@github.com'
git add data/
git diff --staged --quiet || git commit -m "Aktualisierte Scraped-Daten"
git push
Leg Proxy-Zugangsdaten in GitHub Secrets ab, und schon hast du eine kostenlose, automatisierte Scraping-Pipeline.
No-Code-Alternative: Thunderbits geplanter Scraper
Für Teams, die weder Cron-Syntax noch Cloud-Infrastruktur verwalten möchten, bietet Thunderbit einen integrierten Scheduled Scraper. Du beschreibst den Zeitplan in normaler Sprache (z. B. „jeden Tag um 8 Uhr“ oder „jeden Montag“), fügst deine Amazon-URLs hinzu und klickst auf „Schedule“. Kein Terminal, keine YAML-Dateien, keine Deployment-Pipeline. Besonders praktisch für E-Commerce-Teams, die Preis oder Bestand laufend im Blick behalten.
Python-DIY vs. Scraper API vs. No-Code: Welche Lösung solltest du wählen?
Diese Frage sehe ich in Foren am laufenden Band, und keiner der Top-Artikel gibt eine strukturierte Antwort. Deshalb hier meine ehrliche Einschätzung:
| Kriterium | Python + BS4/curl_cffi | Scraper API (ScraperAPI, Oxylabs) | No-Code (Thunderbit) |
|---|---|---|---|
| Einrichtungszeit | 30–60 Min. | 10–20 Min. | ca. 2 Min. |
| Programmieren nötig | Ja (Python) | Ja (API-Aufrufe) | Nein |
| Anti-Blocking integriert | Nein (selbst gebaut) | Ja | Ja |
| JS-Rendering | Nur mit Selenium/Playwright | Je nach Anbieter | Ja (Browser- oder Cloud-Modus) |
| Scheduling | DIY (Cron/Cloud) | Teilweise | Integriert |
| Kosten | Kostenlos (+ Proxy-Kosten) | 30–100+ USD/Monat | Kostenlose Stufe verfügbar |
| Wartung | Hoch (Selektoren brechen) | Niedrig | Keine (KI passt sich an) |
| Am besten für | Entwickler, die volle Kontrolle wollen | Skalierung und Zuverlässigkeit bei Volumen | Schnelligkeit, Nicht-Entwickler, Business-User |
Python ist die richtige Wahl, wenn du lernen, jedes Detail anpassen und vor laufender Wartung nicht zurückschrecken willst. Scraper APIs nehmen dir das Anti-Blocking ab, verlangen aber weiterhin Code. Und Thunderbit ist der schnellste Weg für Sales, E-Commerce-Operations oder alle, die schlicht die Daten brauchen – ohne Selektoren, ohne Code, ohne Wartungsstress, wenn Amazon sein HTML umbaut.
Wie Thunderbit Amazon-Produkte in 2 Klicks scrapt
Klar bin ich voreingenommen – mein Team hat das Tool gebaut. Aber der Ablauf ist wirklich so schlicht:
- Installiere die Thunderbit Chrome-Erweiterung
- Öffne eine Amazon-Suchergebnisseite oder eine Produktseite
- Klicke auf „KI-Felder vorschlagen“ (oder nutze die sofort einsetzbare Amazon-Scraper-Vorlage)
- Klicke auf „Scrape“
Thundersbits KI liest die Seite, erkennt die Datenstruktur und extrahiert alles in eine saubere Tabelle. Den Export nach Excel, Google Sheets, Airtable oder Notion bekommst du kostenlos. Der eigentliche Clou: Ändert Amazon nächste Woche sein HTML – und das wird passieren – stellt sich Thunderbits KI von allein darauf ein. Keine kaputten Skripte, keine Selektor-Updates.
Zum Anreichern von Produktlisten mit Detailseiten-Daten folgt Thunderbits Funktion Subpage Scraping automatisch den Links zu den Produktseiten und zieht zusätzliche Felder wie Bilder, Beschreibungen und Varianten hinein – etwas, das in Python deutlich mehr Zusatzcode kostet.
Tipps, damit dein Python-Amazon-Scraper langfristig läuft
Gehst du den Python-Weg, drückst du mit diesen Maßnahmen den Wartungsaufwand spürbar nach unten:
- Selektoren regelmäßig prüfen. Amazon dreht häufig daran. Setz ein Lesezeichen auf diesen Artikel – ich aktualisiere die Selektortabelle bei Änderungen.
- Erfolgsquote überwachen. Miss das Verhältnis von 200-Antworten zu 503s/CAPTCHAs. Richte eine Warnung ein (notfalls per E-Mail), falls deine Erfolgsrate unter 80 % rutscht.
- Rohes HTML speichern. Bewahre die vollständige HTML-Antwort neben den geparsten Daten auf. Ändern sich Selektoren, kannst du historische Daten neu parsen, ohne erneut zu scrapen.
- Proxies und User-Agents häufig rotieren. Statische Fingerprints fliegen im großen Maßstab binnen Stunden auf.
- Exponential Backoff nutzen. Niemals direkt nach einem Block erneut versuchen.
- Mit Docker containerisieren. Pack deinen Scraper in einen Docker-Container für einfaches Deployment und Portabilität.
- Daten validieren. Prüfe, ob Preise numerisch sind, Bewertungen zwischen 1 und 5 liegen und Titel nicht leer sind. Ein Team berichtete nach Einführung von Validierungsschichten von einer 21-%-Reduktion der Folgefehler.
Oder anders: Klingt das alles nach mehr Arbeit, als du dir eigentlich aufhalsen wolltest, überleg, ob ein No-Code-Tool wie Thunderbit nicht besser zu deinem Fall passt. Es ist keine Schande, den schnelleren Weg zu nehmen – ich habe genug Jahre mit dem Debuggen von Scrapern verbracht, um zu wissen: Der beste Code ist manchmal der, den man gar nicht erst schreiben muss.
Rechtliche und ethische Aspekte beim Scraping von Amazon
Weil dieses Thema bei jeder Diskussion über Amazon-Scraping hochkommt, hier ein kurzer Überblick zur Rechtslage:
- Das Scrapen öffentlich verfügbarer Daten ist in den USA grundsätzlich legal. Das wegweisende Urteil hiQ Labs v. LinkedIn (2022) stellte klar, dass der Zugriff auf öffentliche Daten nicht gegen den CFAA verstößt. Später festigten Meta v. Bright Data (2024) und X v. Bright Data (2024) dieses Prinzip.
- Die Nutzungsbedingungen von Amazon verbieten automatisierten Zugriff. Das ist ein zivilrechtliches Thema (Vertragsbruch), kein strafrechtliches. Gerichte trennen diese beiden Ebenen in der Regel klar.
- Amazon v. Perplexity (2025) ist ein laufender Fall rund um KI-Scraping von Amazon-Seiten. Im März 2026 wurde eine einstweilige Verfügung erlassen. Lohnt sich zu beobachten.
- Bleib bei öffentlichen Seiten. Scrape keine login-geschützten Inhalte, keine personenbezogenen Daten und nichts, das eine Authentifizierung verlangt.
- Halte dich an Rate Limits. Belaste Amazons Server nicht unnötig. Eine Pause von 2 bis 5 Sekunden zwischen Anfragen ist vernünftig.
- Nutze Daten verantwortungsvoll. Scrape zur Analyse, nicht zur Weiterveröffentlichung urheberrechtlich geschützter Inhalte.
- Hol dir rechtlichen Rat für kommerzielle Nutzung in großem Maßstab, besonders im EU-Raum – dort greift für personenbezogene Daten die DSGVO.
Für einen tieferen Einblick wirf einen Blick in unseren Leitfaden zu den rechtlichen Auswirkungen von Web Scraping.
Fazit
Du hast jetzt einen funktionierenden Python-Amazon-Scraper mit verifizierten Selektoren für 2025, eine mehrstufige Anti-Blocking-Strategie, die weit über „füg einen User-Agent hinzu“ hinausgeht, praxisnahe Scheduling-Optionen für kontinuierliches Monitoring und Exportwege, über die deine Daten in Google Sheets, Datenbanken oder jedes andere Tool im Team gelangen.
Kurz zusammengefasst:
- Python + curl_cffi + BeautifulSoup gibt dir volle Kontrolle und zusammen mit TLS-Imitation etwa 94 % Erfolgsrate
- Anti-Blocking braucht mehrere Ebenen: Header-Rotation, TLS-Imitation, Proxy-Rotation, Rate Limiting und exponentielles Backoff
- Scheduling macht aus einem Einmal-Skript eine kontinuierliche Monitoring-Pipeline (Cron, GitHub Actions oder Thunderbits integrierter Scheduler)
- Export über CSV hinaus – Google Sheets, SQLite, Airtable, Notion – ist der Ort, an dem echter geschäftlicher Mehrwert entsteht
- Thunderbit bietet eine 2-Klick-Alternative für Nicht-Entwickler oder alle, die ihre Zeit lieber in Datenanalyse statt in Selektor-Debugging stecken
Willst du den Code ausprobieren, ist alles in diesem Leitfaden direkt kopier- und lauffähig. Und wenn du ganz ohne Programmieren starten möchtest, kannst du mit der kostenlosen Stufe von Thunderbit den No-Code-Ansatz sofort auf Amazon testen.
Mehr dazu findest du in unseren Anleitungen zu Amazon-Produkte und Bewertungen scrapen, den besten Python-Web-Scraping-Tools und Amazon-Preise scrapen. Außerdem gibt es Schritt-für-Schritt-Anleitungen auf dem Thunderbit YouTube-Kanal.
Viel Erfolg beim Scrapen – und mögen deine Selektoren bis zum nächsten Amazon-Update durchhalten.
FAQs
1. Warum wird mein Python-Amazon-Scraper schon nach wenigen Anfragen blockiert?
Amazon setzt auf ein sechsstufiges Abwehrsystem: IP-Reputationsanalyse, TLS-Fingerprinting (JA3/JA4), Erkennung der Browserumgebung, Verhaltensbiometrie, CAPTCHA-Prüfungen und ML-basierte Anomalieerkennung. Ein simples requests-Skript mit nur einem User-Agent-Header kommt auf gerade einmal etwa 2 % Erfolg. Für stabilen Zugriff brauchst du TLS-Imitation (curl_cffi), vollständige Header-Rotation, Proxy-Rotation und Rate Limiting mit zufälligem Jitter.
2. Welche Python-Libraries eignen sich 2025 am besten für Amazon-Scraping?
curl_cffi für TLS-imitierten HTTP-Zugriff (der größte Einzelgewinn), BeautifulSoup4 mit lxml fürs HTML-Parsing, pandas für Datenstrukturierung und Export sowie Selenium oder Playwright als Fallback für per JavaScript gerenderte Inhalte. Python nutzen 69,6 % der Scraping-Entwickler.
3. Ist es legal, Amazon-Produktdaten zu scrapen?
Das Scrapen öffentlich verfügbarer Daten ist in den USA grundsätzlich legal, gestützt durch Urteile wie hiQ v. LinkedIn und Meta v. Bright Data. Die Nutzungsbedingungen von Amazon verbieten automatisierten Zugriff, doch Gerichte trennen zwischen AGB-Verstößen (zivilrechtlich) und strafrechtlichen Verstößen. Meide grundsätzlich login-geschützte Inhalte, halte dich an Rate Limits und hol dir bei großem kommerziellen Einsatz rechtlichen Rat.
4. Kann ich Amazon scrapen, ohne Code zu schreiben?
Ja. Tools wie Thunderbit lassen dich Amazon-Produkte mit einer Chrome-Erweiterung in 2 Klicks scrapen. Die KI-gestützte Felderkennung strukturiert die Daten automatisch, und du kannst kostenlos nach Excel, Google Sheets, Airtable oder Notion exportieren. Ändert Amazon sein HTML, stellt sich Thunderbits KI ohne manuelle Anpassungen darauf ein.
5. Wie oft ändert Amazon seine HTML-Selektoren, und wie halte ich meinen Scraper aktuell?
Häufig und ohne Vorwarnung. In der Scraping-Community heißt es, dass 10–15 % der Crawler wegen DOM-Änderungen wöchentlich nachgezogen werden müssen. Um vorn zu bleiben, überwache die Erfolgsrate deines Scrapers, speichere rohes HTML fürs erneute Parsen und prüfe Selektoren regelmäßig gegen Live-Seiten. Alternativ stellen sich KI-gestützte Tools wie Thunderbit automatisch um und nehmen dir diesen Wartungsaufwand ab.
Mehr erfahren
