Lerne, wie du Amazon-Produkte mit Python scrapest

Wenn du schon mal ein Amazon-Scraping-Tutorial ausprobiert hast und dann an CAPTCHAs, 503-Fehlern oder komplett leeren Ergebnissen gescheitert bist — willkommen im Club. Die meisten Python-Guides zum Amazon-Scraping, die im Netz herumgeistern, stammen aus 2022 oder 2023 und arbeiten mit Selektoren und Methoden, die Amazon längst gefixt hat.

Ich habe bei Thunderbit jahrelang an Datenextraktions-Tools gebaut, und aus der Praxis kann ich dir eines sagen: Amazon gehört zu den härtesten Websites, wenn es um verlässliches Scraping geht. Die Plattform ändert ihr HTML ständig, setzt eine sechsstufige Anti-Bot-Abwehr ein und zeigt per A/B-Testing sogar unterschiedlichen Nutzern unterschiedliche Seitenlayouts. In diesem Leitfaden führe ich dich durch einen Python-Amazon-Scraper, der 2025 wirklich funktioniert — mit verifizierten CSS-Selektoren, einer mehrstufigen Anti-Blocking-Strategie sowie Hinweisen zu Scheduling und Export, die in den meisten Tutorials komplett fehlen. Und für alle, die die Daten einfach brauchen, ohne sich mit Python herumzuschlagen, zeige ich dir außerdem, wie dieselbe Aufgabe in etwa zwei Klicks erledigt.

Was ist Amazon-Produktscraping?

Amazon-Produktscraping bezeichnet das automatisierte Auslesen öffentlich verfügbarer Daten — etwa Produktnamen, Preise, Bewertungen, Anzahl der Rezensionen, Bilder, Verfügbarkeit und mehr — von Amazon-Produktseiten und Suchergebnisseiten. Statt Informationen aus hunderten Angeboten manuell zu kopieren, besucht ein Scraper jede Seite, liest das HTML aus und extrahiert die gewünschten Daten in ein strukturiertes Format wie CSV, Excel oder eine Datenbank.

Stell es dir vor wie einen unermüdlichen Praktikanten, der in der Zeit, die du für deinen ersten Kaffee brauchst, tausend Produktseiten abklappert. Nur macht dieser Praktikant nie Rechtschreibfehler und braucht keine Mittagspause.

Warum Amazon-Produkte mit Python scrapen?

Auf Amazon gibt es grob in mehr als 30 Kategorien, betrieben von rund . Drittanbieter machen inzwischen 69 % des gesamten GMV aus. Schon einen kleinen Teil dieses Katalogs manuell zu überwachen ist schlicht unmöglich. Darum scrapen Teams Amazon:

Schon die schiere Dynamik der Amazon-Preise macht Automatisierung unverzichtbar: Amazon ändert Preise , und der Preis eines durchschnittlichen Produkts aktualisiert sich etwa alle 10 Minuten. Zum Vergleich: Wettbewerber wie Best Buy und Walmart ändern ihre Preise nur rund 50.000 Mal pro Monat. Kein Team aus Menschen kann da mithalten.

Python gibt dir die volle Kontrolle über den Scraping-Prozess — du entscheidest, was extrahiert wird, wie Fehler behandelt werden und wo die Daten landen. Gleichzeitig trägst du aber auch die Verantwortung für Wartung, Anti-Blocking und die ständigen HTML-Änderungen bei Amazon.

Was du von Amazon scrapen kannst — und was nicht

Von öffentlich zugänglichen Produktseiten kannst du in der Regel folgende Daten extrahieren:

• 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.)

Das solltest du vermeiden:

• 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 sind für Analysen in Ordnung, aber veröffentliche sie nicht als deine eigenen

Die von Amazon blockiert über 50 bekannte Bots (darunter GPTBot, Scrapy und ClaudeBot) und untersagt Pfade wie Benutzerkonten, Warenkörbe und Wunschlisten. Produktdetailseiten sind nicht ausdrücklich gesperrt, aber die Nutzungsbedingungen von Amazon untersagen automatisierten Zugriff dennoch. Gerichte unterscheiden 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:

Optional (für Inhalte, die per JavaScript gerendert werden):

• selenium oder playwright — Headless-Browser-Automatisierung

Deine Python-Umgebung einrichten

Öffne dein Terminal und führe Folgendes aus:

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # Unter Windows: venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

Prüfe anschließend, ob alles installiert wurde:

1import requests, bs4, curl_cffi, pandas
2print("Alles gut!")

Wenn du ohne Fehler „Alles gut!“ siehst, kann es losgehen.

Warum die meisten Amazon-Scraping-Tutorials kaputtgehen — und warum dieses anders ist

Das ist der Teil, den die meisten Guides überspringen — und genau der Grund, warum du diesen Artikel wahrscheinlich gerade liest.

Amazon aktualisiert regelmäßig seine HTML-Struktur, Klassennamen und Element-IDs. In der Scraping-Community ist bekannt, dass , weil sich das DOM verschiebt und Fingerprinting-Methoden geändert werden. Der bekannteste Ausfall? Der Selektor #priceblock_ourprice, der in hunderten Tutorials von 2018 bis 2023 auftauchte. Diese ID gibt es auf Amazon-Produktseiten längst nicht mehr.

Ein schneller Vergleich: was kaputt ist und was heute funktioniert:

Jeder Codeausschnitt in diesem Leitfaden wurde 2025 gegen echte Amazon-Seiten getestet. Ich zeige dir die tatsächlichen CSS-Selektoren samt erwarteter Ausgabe — kein Copy-Paste 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 , 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 beginnen mit einem simplen requests.get():

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(response.text[:500])

Wenn du das ausführst, bekommst du mit hoher Wahrscheinlichkeit einen 503-Statuscode oder eine Seite mit dem Hinweis „To discuss automated access to Amazon data please contact…“. Das ist Amazons WAF (Web Application Firewall), die dein Python-Skript erkannt hat. Ein nacktes requests.get() ohne passende Header erreicht gegen Amazon nur etwa eine .

Du solltest also etwas wie 503 und eine Blockseite im HTML sehen. Das ist normal — wir beheben das im nächsten Schritt.

Schritt 2: Eigene Header und TLS-Imitation einrichten

Einfach nur einen User-Agent zu setzen reicht heute nicht mehr. Amazon vergleicht deine HTTP-Header mit deinem TLS-Fingerprint. Wenn du angibst, Chrome 120 zu sein, aber der TLS-Handshake zeigt die Python-requests-Bibliothek, wirst du .

Der verlässlichste Weg im Jahr 2025 ist curl_cffi mit Browser-Imitation:

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

Mit curl_cffi und der Imitation von Chrome 124 steigen die Erfolgsraten auf etwa — also das 47-Fache von einfachem requests. Du solltest jetzt einen 200-Statuscode und eine deutlich längere HTML-Antwort sehen (100.000+ Zeichen).

Wenn du trotzdem noch einen 503 bekommst, versuche einen anderen impersonate-Wert (z. B. "chrome131") oder füge vor dem erneuten Versuch eine kurze Pause ein.

Schritt 3: HTML parsen und Produktdaten extrahieren

Jetzt, da wir das vollständige HTML haben, extrahieren wir die Daten mit BeautifulSoup und verifizierten Selektoren für 2025:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# Produkttitel
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# Preis
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# Bewertung
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# Anzahl der Rezensionen
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# Verfügbarkeit
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# URL des Hauptbilds
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Titel: {title}")
28print(f"Preis: {price}")
29print(f"Bewertung: {rating}")
30print(f"Rezensionen: {reviews}")
31print(f"Verfügbarkeit: {availability}")
32print(f"Bild: {image_url}")

Beispielausgabe:

1Titel: Apple AirPods Pro (2. Generation) mit USB-C
2Preis: $189.99
3Bewertung: 4.7 von 5 Sternen
4Rezensionen: 98,432 Bewertungen
5Verfügbarkeit: Auf Lager
6Bild: https://m.media-amazon.com/images/I/61SUj2...

Achte auf die mehreren Fallback-Selektoren beim Preis — Amazon verwendet je nach Produkttyp, Angebotsstatus und A/B-Test unterschiedliche Container. Wenn du jede Extraktion mit einer Bedingung absicherst, stürzt dein Scraper nicht ab, sobald ein Selektor kein Match findet.

Schritt 4: Mehrere Produkte aus den Suchergebnissen scrapen

Wenn du einen echten Datensatz aufbauen willst, startest du am besten mit einer Amazon-Suchergebnisseite, sammelst ASINs und scrapest dann jede Produktdetailseite.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """ASINs aus den Amazon-Suchergebnissen sammeln."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"Suchseite {page} lieferte {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Seite {page}: {len(results)} Produkte gefunden")
19        time.sleep(random.uniform(2, 5))  # Höfliche Pause
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"{len(asins)} ASINs gesammelt")

Jede ASIN lässt sich einer sauberen Produkt-URL zuordnen: https://www.amazon.com/dp/{ASIN}. Das ist robuster als die vollständigen Suchresultat-URLs, die oft sitzungsspezifische Parameter enthalten.

Schritt 5: Pagination behandeln und im großen Stil scrapen

Jetzt kombinieren wir Suchsammlung und Detailseiten-Scraping zu einer vollständigen Pipeline:

1import pandas as pd
2def scrape_product(asin):
3    """Eine einzelne Amazon-Produktdetailseite scrapen."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Fehler beim Scrapen von {asin}: {e}")
32        return None
33# Alle gesammelten ASINs scrapen
34products = []
35for i, asin in enumerate(asins):
36    print(f"Scrape {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # Zufällige Pause zwischen den Requests
41df = pd.DataFrame(products)
42print(f"\n{len(df)} Produkte erfolgreich gescrapt")
43print(df.head())

Die zufällige Pause von 2 bis 5 Sekunden ist entscheidend. Perfekt regelmäßige Intervalle (z. B. immer genau 3 Sekunden) wirken auf Amazons Verhaltensanalyse verdächtig. Zufällige Abstände sehen eher nach menschlichem Browsing aus.

Schritt 6: Amazon-Daten als CSV speichern

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("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 hören die meisten Tutorials auf — aber wenn du einen echten Workflow baust, ist CSV nur der Anfang.

Deep Dive Anti-Blocking: So hältst du deinen Scraper am Laufen

Blockiert zu werden ist der 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 eine mehrstufige Strategie für jede dieser Ebenen.

User-Agents und vollständige Header rotieren

Ein einzelner statischer User-Agent wird schnell erkannt. Wechsle zwischen aktuellen Browser-Strings:

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "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",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

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 haben wir in Schritt 2 bereits behandelt, aber es ist wichtig genug, um es noch einmal zu betonen: Diese einzelne Technik bringt den größten Sprung bei der Erfolgsrate. Standard-Python-requests schafft bei Amazon etwa 2 % Erfolg. Mit curl_cffi und Imitation liegt man bei ungefähr 94 %. Das ist der Unterschied zwischen einem funktionierenden und einem kaputten Scraper.

1from curl_cffi import requests as cfreq
2# Auch die Imitationsziele rotieren
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

Proxy-Rotation

Wenn du mehr als nur ein paar Seiten scrapen willst, brauchst du Proxy-Rotation. Amazon verfolgt IP-Adressen und blockiert jede einzelne IP, die zu viele Requests sendet.

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

Residential-Proxies sind wirksamer als Rechenzentrums-Proxies (Amazon blockiert Rechenzentrumsbereiche proaktiv), sind aber auch teurer. Für ein kleines Projekt kannst du mit einem starten und bei Bedarf skalieren.

Rate Limiting und exponentielles Backoff

Kein Konkurrenzartikel, den ich gefunden habe, behandelt das sauber, dabei ist es entscheidend. Wenn du eine 503- oder CAPTCHA-Antwort bekommst, versuche nicht sofort erneut — das ist der direkte Weg zur dauerhaften Sperre.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """Eine URL mit exponentiellem Backoff bei Fehlern abrufen."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Exponentielles Backoff mit Jitter
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Versuch {attempt+1} fehlgeschlagen ({response.status_code}). Warte {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # Alle Wiederholungen ausgeschöpft

Die Formel wait = min(2^attempt + jitter, max_delay) sorgt dafür, dass deine Pausen wachsen (2 s, 4 s, 8 s …), aber nie unvernünftig lang werden. Der zufällige Jitter verhindert außerdem, dass dein Retry-Muster erkannt wird.

Selenium- oder Playwright-Fallback für JS-gerenderte Inhalte

Manche Amazon-Seiten — vor allem mit dynamischen Preis-Widgets oder Varianten-Auswahl — benötigen JavaScript, um vollständig zu rendern. Wenn curl_cffi nur unvollständiges HTML liefert, ist ein Headless-Browser dein Ausweg:

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # JS rendern lassen
8        html = page.content()
9        browser.close()
10        return html

Das ist langsamer — 3 bis 5 Sekunden pro Seite statt unter 1 Sekunde mit curl_cffi. Verwende es nur, wenn es nötig ist.

Aus meiner Erfahrung schafft curl_cffi über 90 % der Amazon-Produktseiten ohne Browser.

Anti-Blocking-Zusammenfassung

Mehr als CSV: Amazon-Daten nach Google Sheets, Airtable und mehr exportieren

Jedes Tutorial, das ich geprüft habe, endet beim CSV-Export. In echten Geschäftsprozessen müssen die Daten aber in Google Sheets, Datenbanken oder Tools wie Airtable und Notion landen.

Mit gspread nach Google Sheets exportieren

Richte zuerst ein Google-Service-Account ein (einmaliger Aufwand):

1. Öffne die → APIs & Services → Credentials
2. Erstelle einen Service-Account und lade die JSON-Key-Datei herunter
3. Speichere sie unter ~/.config/gspread/service_account.json
4. Teile dein Ziel-Spreadsheet mit der client_email aus der JSON-Datei

Dann:

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("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:

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"{len(df)} Produkte in SQLite gespeichert")
5# Später abfragen:
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

Die No-Code-Alternative

Wenn du keine Python-Exportskripte pflegen möchtest, bietet 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 bestehenden Tools fließen lassen wollen, ist das eine enorme Zeitersparnis.

Automatisierte Amazon-Scrapes planen — das fehlende Kapitel

Preisüberwachung und Bestandskontrolle brauchen wiederkehrende Scrapes, keine Einmal-Läufe. Trotzdem habe ich keinen einzigen Konkurrenzartikel gefunden, der Scheduling behandelt. So automatisierst du deinen Python-Scraper.

Cron-Jobs (Linux/macOS)

Öffne dein Crontab:

1crontab -e

Füge eine Zeile hinzu, damit dein Scraper täglich um 6 Uhr morgens läuft:

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Oder alle 6 Stunden:

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

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

Dann öffne 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:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # Täglich um 6 Uhr UTC
5  workflow_dispatch:       # Manueller Start
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Python einrichten
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Abhängigkeiten installieren
16        run: pip install -r requirements.txt
17      - name: Scraper ausführen
18        run: python scraper.py
19      - name: Ergebnisse committen
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Aktualisierte Scraped-Daten"
25          git push

Speichere Proxy-Zugangsdaten in GitHub Secrets, und du hast eine kostenlose, automatisierte Scraping-Pipeline.

No-Code-Alternative: Thunderbits geplanter Scraper

Für Teams, die keine Cron-Syntax oder Cloud-Infrastruktur verwalten möchten, bietet Thunderbit einen integrierten . 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. Das ist besonders nützlich für E-Commerce-Teams, die Preis oder Bestand kontinuierlich überwachen.

Python-DIY vs. Scraper API vs. No-Code: Welche Lösung solltest du wählen?

Diese Frage sehe ich in Foren ständig, und keiner der Top-Artikel bietet eine strukturierte Antwort. Daher hier meine ehrliche Einschätzung:

Python ist die richtige Wahl, wenn du lernen, jedes Detail anpassen und laufende Wartung nicht scheust. Scraper APIs nehmen dir zwar das Anti-Blocking ab, erfordern aber weiterhin Code. Und Thunderbit ist der schnellste Weg für Sales, E-Commerce-Operations oder alle, die einfach nur die Daten brauchen — ohne Selektoren, ohne Code, ohne Wartungsaufwand, wenn Amazon sein HTML ändert.

Wie Thunderbit Amazon-Produkte in 2 Klicks scrapt

Natürlich bin ich voreingenommen — mein Team hat das Tool gebaut. Aber der Ablauf ist wirklich so einfach:

1. Installiere die
2. Öffne eine Amazon-Suchergebnisseite oder eine Produktseite
3. Klicke auf „KI-Felder vorschlagen“ (oder nutze die sofort einsetzbare Amazon-Scraper-Vorlage)
4. Klicke auf „Scrape“

Thundersbits KI liest die Seite, erkennt die Datenstruktur und extrahiert alles in eine saubere Tabelle. Du kannst kostenlos nach Excel, Google Sheets, Airtable oder Notion exportieren. Der eigentliche Vorteil: Wenn Amazon nächste Woche sein HTML ändert — und das wird passieren — passt sich Thunderbits KI automatisch an. Keine kaputten Skripte, keine Selektor-Updates.

Für die Anreicherung 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 erfordert.

Tipps, damit dein Python-Amazon-Scraper langfristig läuft

Wenn du den Python-Weg gehst, kannst du mit diesen Maßnahmen den Wartungsaufwand deutlich senken:

• Selektoren regelmäßig prüfen. Amazon ändert sie häufig. Setze dir 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 (zur Not per E-Mail), wenn deine Erfolgsrate unter 80 % fällt.
• Rohes HTML speichern. Bewahre die vollständige HTML-Antwort zusammen mit den geparsten Daten auf. Wenn sich Selektoren ändern, kannst du historische Daten neu parsen, ohne erneut scrapen zu müssen.
• Proxies und User-Agents häufig rotieren. Statische Fingerprints werden im großen Maßstab innerhalb von Stunden erkannt.
• Exponential Backoff nutzen. Niemals sofort nach einem Block erneut versuchen.
• Mit Docker containerisieren. Verpacke deinen Scraper in einen Docker-Container für einfache Bereitstellung 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 über eine .

Oder: Wenn dir das alles mehr Arbeit klingt, als du eigentlich auf dich nehmen wolltest, überlege, ob ein No-Code-Tool wie Thunderbit nicht besser zu deinem Fall passt. Es ist keine Schande, den schnelleren Weg zu wählen — ich habe genug Jahre damit verbracht, Scraper zu debuggen, um zu wissen, dass der beste Code manchmal der ist, den man gar nicht erst schreiben muss.

Rechtliche und ethische Aspekte beim Scraping von Amazon

Weil dieses Thema bei jeder Diskussion über Amazon-Scraping aufkommt, hier ein kurzer Überblick zur Rechtslage:

• Das Scrapen öffentlich verfügbarer Daten ist in den USA grundsätzlich legal. Das wegweisende Urteil (2022) stellte klar, dass der Zugriff auf öffentliche Daten nicht gegen den CFAA verstößt. Später stärkten (2024) und (2024) dieses Prinzip.
• Die Nutzungsbedingungen von Amazon verbieten automatisierten Zugriff. Das ist ein zivilrechtliches Thema (Vertragsbruch), kein strafrechtliches. Gerichte unterscheiden zwischen diesen beiden Ebenen in der Regel klar.
• Amazon v. Perplexity (2025) ist ein laufender Fall im Zusammenhang mit KI-Scraping von Amazon-Seiten. Im März 2026 wurde eine einstweilige Verfügung erlassen. Das lohnt sich zu beobachten.
• Bleib bei öffentlichen Seiten. Scrape keine login-geschützten Inhalte, keine personenbezogenen Daten und nichts, das eine Authentifizierung erfordert.
• 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 wenn du in der EU bist (dann gilt die DSGVO für personenbezogene Daten).

Für einen tieferen Einblick sieh dir unseren Leitfaden zu den an.

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, mit denen 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 verwandelt ein Einmal-Skript in 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 mit Datenanalyse statt mit Selektor-Debugging verbringen

Wenn du den Code ausprobieren möchtest, ist alles in diesem Leitfaden direkt kopier- und lauffähig. Und wenn du ganz ohne Programmieren starten willst, kannst du mit der den No-Code-Ansatz sofort auf Amazon testen.

Mehr dazu findest du in unseren Anleitungen zu , und . Außerdem kannst du Schritt-für-Schritt-Anleitungen auf dem ansehen.

Viel Erfolg beim Scrapen — und mögen deine Selektoren bis zum nächsten Amazon-Update überleben.

FAQs

1. Warum wird mein Python-Amazon-Scraper schon nach wenigen Anfragen blockiert?

Amazon nutzt ein sechsstufiges Abwehrsystem: IP-Reputationsanalyse, TLS-Fingerprinting (JA3/JA4), Erkennung der Browserumgebung, Verhaltensbiometrie, CAPTCHA-Prüfungen und ML-basierte Anomalieerkennung. Ein einfaches requests-Skript mit nur einem User-Agent-Header erreicht nur etwa Erfolg. Du brauchst TLS-Imitation (curl_cffi), vollständige Header-Rotation, Proxy-Rotation und Rate Limiting mit zufälligem Jitter, um stabilen Zugriff zu halten.

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ür HTML-Parsing, pandas für Datenstrukturierung und Export sowie Selenium oder Playwright als Fallback für per JavaScript gerenderte Inhalte. Python wird von der Scraping-Entwickler genutzt.

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, aber Gerichte unterscheiden zwischen AGB-Verstößen (zivilrechtlich) und strafrechtlichen Verstößen. Vermeide immer login-geschützte Inhalte, halte dich an Rate Limits und hole bei großem kommerziellen Einsatz rechtlichen Rat ein.

4. Kann ich Amazon scrapen, ohne Code zu schreiben?

Ja. Tools wie ermöglichen dir, Amazon-Produkte mit einer Chrome-Erweiterung in 2 Klicks zu scrapen. Die KI-gestützte Felderkennung strukturiert die Daten automatisch, und du kannst kostenlos nach Excel, Google Sheets, Airtable oder Notion exportieren. Wenn Amazon sein HTML ändert, passt sich Thunderbits KI ohne manuelle Anpassungen an.

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 der Crawler wegen DOM-Änderungen wöchentlich angepasst werden müssen. Um voraus zu sein, überwache die Erfolgsrate deines Scrapers, speichere rohes HTML für erneutes Parsen und prüfe Selektoren regelmäßig gegen Live-Seiten. Alternativ passen sich KI-gestützte Tools wie Thunderbit automatisch an und nehmen dir diesen Wartungsaufwand ab.

Mehr erfahren