Scrapen von Amazon Produktdaten mit Python: Hands-On Anleitung

Bevor Sie auch nur eine einzige Zeile Code schreiben, ist es hilfreich zu wissen, welches Problem Sie lösen wollen. Amazon-Produktdaten treiben eine überraschend große Bandbreite an realen Arbeitsabläufen an:

• Preisüberwachung und -analyse. Einzelhändler und Wiederverkäufer verfolgen die Preise der Konkurrenz über Tausende von ASINs hinweg, um ihre eigenen Preise dynamisch anzupassen.
• Marktforschung und Trendanalyse. Analysten untersuchen Bestseller-Rankings, die Anzahl der Bewertungen und die Verteilung auf verschiedene Kategorien, um aufkommende Produkttrends zu erkennen.
• Bewertungs- und Stimmungsanalyse. Produktteams scrapen Amazon-Produktbewertungen, um Kundenprobleme, Feature-Anfragen und Qualitätssignale in großem Maßstab zu verstehen.
• ML- und KI-Trainingsdaten. Strukturierte Produktkataloge dienen als beschriftete Datensätze für Empfehlungsmaschinen, Bildklassifikatoren und Modelle für natürliche Sprache.

Da Amazon Daten von Millionen von Verkäufern aus praktisch jeder Verbraucherkategorie aggregiert, ist sein Katalog einzigartig umfassend. Durch das Sammeln dieser Daten können Unternehmen die Produktpositionierung, Preisentwicklungen und Verschiebungen in der Marktnachfrage überwachen, die durch manuelles Durchsuchen allein nicht erkennbar wären.

Das ist die Frage, die sich jeder zuerst stellt, und die ehrliche Antwort lautet: Es kommt darauf an, was Sie scrapen und wie Sie dabei vorgehen.

Die Nutzungsbedingungen von Amazon verbieten ausdrücklich „die Verwendung von Robotern, Spidern, Scrapern oder anderen automatisierten Mitteln, um für irgendeinen Zweck auf den Dienst zuzugreifen“. Diese Formulierung ist weit gefasst, und Amazon hat sie in der Vergangenheit durchgesetzt. Gleichzeitig hat das US-Gericht im Fall „hiQ Labs gegen LinkedIn“ aus dem Jahr 2022 entschieden, dass das Scraping öffentlich zugänglicher Daten zumindest in diesem spezifischen Kontext nicht gegen den Computer Fraud and Abuse Act verstößt. Gerichte in anderen Rechtsordnungen könnten zu anderen Schlussfolgerungen gelangen.

In der Praxis befolgen die meisten Entwickler, die Amazon-Produktseiten scrapen, einige verantwortungsbewusste Richtlinien: Sie erfassen nur öffentlich sichtbare Informationen, greifen niemals auf durch Login geschützte personenbezogene Daten zu, halten sich an Ratenbeschränkungen und vermeiden es, Server mit aggressiven Anfragevolumina zu überlasten. Konsultieren Sie einen qualifizierten Rechtsbeistand, wenn Ihr Anwendungsfall die groß angelegte kommerzielle Datenerfassung umfasst. Der CFAA-Reform-Tracker der EFF ist eine nützliche Ressource, um über die sich entwickelnde Rechtslage rund um den automatisierten Datenzugriff auf dem Laufenden zu bleiben.

Nicht jedes Projekt benötigt einen maßgeschneiderten Scraper. Bevor Sie sich in den Code vertiefen, sollten Sie überlegen, welcher Ansatz Ihrem technischen Niveau, Ihrem Budget und Ihrer Bereitschaft zur Wartung entspricht. Hier ist ein kurzer Entscheidungsleitfaden:

Wenn Sie genau verstehen möchten, wie Amazon-Seiten aufgebaut sind, und die volle Kontrolle über jeden CSS-Selektor benötigen, ist der DIY-Python-Weg ideal, um zu lernen, wie Sie Amazon-Produktlisten selbst scrapen können. Wenn Ihre Priorität auf einer zuverlässigen Datenlieferung liegt, ohne sich um einen Proxy-Pool kümmern zu müssen, nimmt Ihnen eine dedizierte Scraping-API den größten Teil des Betriebsaufwands ab. Und wenn Sie ein Business-Analyst sind, der lieber nicht mit einem Terminal hantieren möchte, können Sie auf mehreren No-Code-Plattformen Amazon-Scraper über eine visuelle Oberfläche konfigurieren.

Der Rest dieses Leitfadens konzentriert sich auf den DIY-Python-Weg, aber wir werden später mit einem konkreten Code-Beispiel auf den API-Ansatz zurückkommen.

Sie benötigen Python 3.8 oder höher sowie drei Pakete. Öffnen Sie ein Terminal und führen Sie folgenden Befehl aus:

pip install requests beautifulsoup4 lxml

• Requests übernimmt die HTTP-Ebene: das Senden von GET-Anfragen, die Verwaltung von Headern und das Empfangen von Antworten.
• BeautifulSoup parst den rohen HTML-String in einen navigierbaren Baum, den Sie mit CSS-Selektoren abfragen können.
• lxml ist ein optionales, aber empfohlenes Parser-Backend. Es ist deutlich schneller als Pythons integriertes html.parser bei großen Dokumenten.

Erstellen Sie eine neue Python-Datei (zum Beispiel amazon_scraper.py) und überprüfen Sie die Installationen:

import requests
from bs4 import BeautifulSoup

print("Environment ready")

Wenn dies ohne Fehler läuft, können Sie loslegen.

Bevor Sie Parsing-Logik schreiben, müssen Sie wissen, was Sie parsen. Amazon-Produktlistings erscheinen auf zwei Hauptseitentypen: Suchergebnisseiten und einzelnen Produktdetailseiten. Beide enthalten strukturierte Daten, aber das HTML-Layout unterscheidet sich.

Auf einer Suchergebnisseite befindet sich jede Produktkarte innerhalb eines div mit dem Attribut data-component-type="s-search-result". Innerhalb dieses Containers finden Sie in der Regel:

• Titel: ein h2 Tag, das einen Anker (a) mit dem Produktnamen.
• Preis: ein span mit der Klasse a-price , das ein verschachteltes span.a-offscreen , das die formatierte Preiszeichenfolge enthält.
• Bewertung: ein span.a-icon-alt innerhalb des Sternbewertungsblocks, mit Text wie „4,5 von 5 Sternen“.
• ASIN: gespeichert als data-asin Attribut direkt im Suchergebnis div.
• Bild: ein img Tag mit der Klasse s-image dessen src auf das Produkt-Miniaturbild verweist.

Verwenden Sie die Entwicklertools Ihres Browsers (Rechtsklick, „Element untersuchen“), um diese Selektoren auf einer Live-Seite zu überprüfen. Amazon ändert gelegentlich Klassennamen und Layoutstruktur, daher sollten Sie Selektoren vor dem Einsatz in der Produktion immer validieren. Viele Amazon-Produkte weisen zudem mehrere Varianten auf (Farbe, Größe, Modell), und jede Variante kann einen eigenen Preis, ein eigenes Bild und eine eigene Verfügbarkeit haben. Variationsdaten befinden sich in der Regel auf der Produktdetailseite und nicht auf der Suchergebnisseite, oft eingebettet in ein JavaScript-Objekt, das Sie separat parsen müssen.

Fassen wir die einzelnen Teile zusammen. Der Scraper-Workflow umfasst drei Phasen: die Seite anfordern, die Antwort überprüfen und den HTML-Code analysieren. Hier ist die Grundlage:

import requests
from bs4 import BeautifulSoup

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/120.0.0.0 Safari/537.36"
    ),
    "Accept-Language": "en-US,en;q=0.9",
}

url = "https://www.amazon.com/s?k=mechanical+keyboard"
response = requests.get(url, headers=HEADERS)

if response.status_code == 200:
    soup = BeautifulSoup(response.text, "lxml")
    print(f"Page fetched: {len(response.text)} bytes")
else:
    print(f"Request failed with status {response.status_code}")

Der User-Agent Header ist entscheidend, wenn Sie Amazon-Produktseiten scrapen. Ohne ihn wird Amazon mit ziemlicher Sicherheit eine CAPTCHA-Seite oder einen 503-Status zurückgeben. Sie geben sich damit im Wesentlichen als normaler Browser zu erkennen und nicht als bloßes Python-Skript.

Sobald du das geparste soup Objekt haben, durchlaufen Sie jede Produktkarte und extrahieren Sie die wichtigsten Attribute:

products = []
cards = soup.select('div[data-component-type="s-search-result"]')

for card in cards:
    title_tag = card.select_one("h2 a span")
    price_tag = card.select_one("span.a-price span.a-offscreen")
    rating_tag = card.select_one("span.a-icon-alt")

    product = {
        "title": title_tag.get_text(strip=True) if title_tag else None,
        "price": price_tag.get_text(strip=True) if price_tag else None,
        "rating": rating_tag.get_text(strip=True) if rating_tag else None,
    }
    products.append(product)

print(f"Found {len(products)} products")

Jeder select_one Aufruf zielt auf einen bestimmten CSS-Selektor ab. Die bedingten Prüfungen verhindern, dass Ihr Skript abstürzt, wenn in einer Karte ein Element fehlt (bei gesponserten Ergebnissen wird beispielsweise manchmal der Preis weggelassen).

Bilder und ASINs lassen sich leichter abrufen, da sie sich direkt im Karten-Container befinden:

for i, card in enumerate(cards):
    asin = card.get("data-asin", "")
    img_tag = card.select_one("img.s-image")
    img_url = img_tag["src"] if img_tag else None

    products[i]["asin"] = asin
    products[i]["image_url"] = img_url

Die ASIN (Amazon Standard Identification Number) ist eine eindeutige Produktkennung. Sie ist nützlich für die Deduplizierung, zum Erstellen von URLs für Produktdetailseiten (https://www.amazon.com/dp/{ASIN}) sowie zum Zusammenführen von Datensätzen aus verschiedenen Scraping-Läufen.

Eine einzelne Amazon-Suchseite zeigt etwa 20 bis 60 Ergebnisse an. Wenn Sie Tausende von Produkten benötigen, müssen Sie Amazon-Produktlisten über mehrere Seiten hinweg scrapen. Amazon verwendet einen page Abfrageparameter, den Sie inkrementieren können:

import time

all_products = []
base_url = "https://www.amazon.com/s?k=mechanical+keyboard&page={page}"

for page_num in range(1, 11):  # pages 1 through 10
    url = base_url.format(page=page_num)
    response = requests.get(url, headers=HEADERS)

    if response.status_code != 200:
        print(f"Stopped at page {page_num}: status {response.status_code}")
        break

    soup = BeautifulSoup(response.text, "lxml")
    cards = soup.select('div[data-component-type="s-search-result"]')

    if not cards:
        print(f"No results on page {page_num}, stopping.")
        break

    for card in cards:
        title_tag = card.select_one("h2 a span")
        price_tag = card.select_one("span.a-price span.a-offscreen")
        all_products.append({
            "title": title_tag.get_text(strip=True) if title_tag else None,
            "price": price_tag.get_text(strip=True) if price_tag else None,
        })

    time.sleep(2)  # respect rate limits

print(f"Total products collected: {len(all_products)}")

Zwei Dinge sind zu beachten. Erstens fügt der time.sleep(2) Aufruf fügt eine Pause von zwei Sekunden zwischen den Anfragen ein. Ohne eine solche zeitliche Staffelung wird Amazon Ihre IP-Adresse fast sofort sperren. Zweitens prüft die Schleife auf eine leere cards Liste als Abbruchbedingung, da Amazon auch dann eine gültige 200-Antwort zurückgibt, wenn keine Ergebnisse mehr vorhanden sind.

Bei umfangreichen Aufgaben, die Hunderte von Seiten umfassen, sollten Sie in Betracht ziehen, die Anfragen auf einen rotierenden Proxy-Pool zu verteilen. Lokales Scraping von einer einzigen IP-Adresse stößt schnell an die Ratenbegrenzung.

Amazon ist bekannt dafür, Scraper zu blockieren, und das aus gutem Grund: Die Plattform verarbeitet Milliarden von Seitenaufrufen. Ihre Abwehrmechanismen sind mehrschichtig, und das Verständnis jeder einzelnen Schicht hilft Ihnen bei der Entscheidung, wie Sie reagieren sollten.

AWS WAF (Web Application Firewall). Amazon nutzt sein eigenes Cloud-Firewall-Produkt, um eingehende Anfragen zu prüfen. WAF analysiert Ihre IP-Adresse, HTTP-Header, den TLS-Fingerabdruck und Verhaltensmuster (Anfragehäufigkeit, Navigationssequenz). Wenn ein Signal nicht menschlich erscheint, wird die Anfrage entweder direkt blockiert oder zu einer CAPTCHA-Abfrage umgeleitet.

CAPTCHA-Herausforderungen. Wenn WAF eine Anfrage markiert, wird in der Regel eine Seite angezeigt, auf der Sie aufgefordert werden, ein Bild- oder Text-CAPTCHA zu lösen. Ein einfacher, auf Anfragen basierender Scraper kann diese nicht automatisch lösen. Zu den Optionen gehören die Integration eines CAPTCHA-Lösungsdienstes, der Wechsel zu einem Headless-Browser oder die Weiterleitung von Anfragen über eine Scraping-API, die CAPTCHAs im Hintergrund verarbeitet.

IP-Blockierung und Ratenbegrenzung. Das Senden zu vieler Anfragen von derselben IP-Adresse innerhalb eines kurzen Zeitfensters löst vorübergehende oder dauerhafte Sperren aus. Durch die Rotation von Residential-Proxys sieht Ihr Traffic so aus, als stamme er von verschiedenen privaten Internetanschlüssen, was für die WAF viel schwieriger von organischen Besuchen zu unterscheiden ist.

Header- und Fingerabdruckanalyse. Minimalistische Request-Header (fehlende Accept-Language, Accept-Encodingoder ein realistischer User-Agent) sind ein sofortiges Warnsignal. Randomisieren Sie Ihre User-Agent-Zeichenfolge über alle Anfragen hinweg und fügen Sie denselben Header-Satz ein, den ein echter Browser senden würde.

Wenn Sie es ernst meinen mit der Entwicklung eines zuverlässigen Amazon-Produkt-Scrapers in Python, sollten Sie zumindest in Proxy-Rotation und Header-Randomisierung investieren. Für die meisten Anwendungsfälle in der Produktion ist eine dedizierte Scraping-API, die diese Schutzmaßnahmen in einem einzigen Endpunkt bündelt, die pragmatische Wahl.

Hier ist ein konsolidiertes Skript, das Umgebungs-Setup, Anfragebearbeitung, Parsing und Paginierung in einer einzigen ausführbaren Datei vereint. Passen Sie den Suchbegriff und den Seitenbereich an Ihre Bedürfnisse an.

import requests
from bs4 import BeautifulSoup
import time
import json
import csv

HEADERS = {
    "User-Agent": (
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
        "AppleWebKit/537.36 (KHTML, like Gecko) "
        "Chrome/120.0.0.0 Safari/537.36"
    ),
    "Accept-Language": "en-US,en;q=0.9",
    "Accept-Encoding": "gzip, deflate, br",
    "Accept": "text/html,application/xhtml+xml",
}

def scrape_amazon(query, max_pages=5):
    all_products = []
    for page in range(1, max_pages + 1):
        url = f"https://www.amazon.com/s?k={query}&page={page}"
        resp = requests.get(url, headers=HEADERS)
        if resp.status_code != 200:
            print(f"Page {page}: HTTP {resp.status_code}")
            break
        soup = BeautifulSoup(resp.text, "lxml")
        cards = soup.select('div[data-component-type="s-search-result"]')
        if not cards:
            break
        for card in cards:
            all_products.append({
                "asin": card.get("data-asin", ""),
                "title": _text(card, "h2 a span"),
                "price": _text(card, "span.a-price span.a-offscreen"),
                "rating": _text(card, "span.a-icon-alt"),
                "image": card.select_one("img.s-image")["src"]
                         if card.select_one("img.s-image") else None,
            })
        time.sleep(2)
    return all_products

def _text(card, selector):
    tag = card.select_one(selector)
    return tag.get_text(strip=True) if tag else None

if __name__ == "__main__":
    results = scrape_amazon("wireless+earbuds", max_pages=3)
    print(f"Scraped {len(results)} products")

Ein paar Anmerkungen, die es wert sind, erwähnt zu werden. Der _text Helper hält die Parsing-Schleife kompakt und verhindert wiederholte None Prüfungen. Der Accept-Encoding und Accept -Header runden den Anforderungs-Fingerabdruck ab, sodass er einem echten Browser ähnlicher erscheint. Und indem alles in eine Funktion gepackt wird, lässt es sich leicht in eine größere Pipeline einbinden oder von einem Scheduler aus aufrufen.

Rohe Python-Dictionaries sind nützlich für die Fehlersuche, aber nachgelagerte Tools (Tabellenkalkulationen, Datenbank-Loader, Analytics-Notebooks) erwarten ein Standard-Dateiformat. So exportieren Sie Ihre gescrapten Amazon-Produktdaten sowohl als CSV als auch als JSON.

Der CSV-Export eignet sich gut für tabellarische Analysen in Excel, Google Sheets oder pandas:

import csv

def export_csv(products, filename="amazon_products.csv"):
    if not products:
        return
    keys = products[0].keys()
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=keys)
        writer.writeheader()
        writer.writerows(products)
    print(f"Exported {len(products)} rows to {filename}")

Der JSON-Export ist die bessere Wahl, wenn Sie verschachtelte Daten benötigen, die Ergebnisse in eine NoSQL-Datenbank laden möchten oder die Daten in eine API einspeisen wollen:

import json

def export_json(products, filename="amazon_products.json"):
    with open(filename, "w", encoding="utf-8") as f:
        json.dump(products, f, indent=2, ensure_ascii=False)
    print(f"Exported {len(products)} items to {filename}")

Wann welches Format: Wählen Sie CSV, wenn Ihre Nutzer Analysten sind, die mit Tabellenkalkulationen arbeiten, oder wenn Sie einen schnellen Import in eine SQL-Tabelle benötigen. Wählen Sie JSON, wenn Sie Datenpipelines aufbauen, verschachtelte Strukturen (wie Produktvarianten) beibehalten müssen oder ein Format wünschen, das direkt auf API-Payloads abgebildet werden kann.

Der DIY-Ansatz gibt Ihnen volle Kontrolle, bedeutet aber auch, dass Sie für jeden Fehlerfall selbst verantwortlich sind: defekte Proxys, CAPTCHA-Barrieren, rotierende Selektoren und IP-Sperren. Wenn es Ihr Ziel ist, Amazon-Produktseiten zuverlässig in einer Produktionspipeline zu scrapen, kann die Auslagerung der Anforderungsschicht an eine dedizierte Scraping-API erhebliche Entwicklungszeit einsparen.

Eine Scraping-API sitzt zwischen Ihrem Code und der Zielwebsite. Sie senden eine normale HTTP-Anfrage an den API-Endpunkt mit der Amazon-URL als Parameter, und der Dienst übernimmt intern die Proxy-Rotation, das Header-Management, das Lösen von CAPTCHAs und Wiederholungsversuche. Sie erhalten sauberes HTML (oder in einigen Fällen vorab geparstes JSON) zurück, das Sie direkt in Ihren BeautifulSoup-Parsing-Code einspeisen können.

Hier ist ein minimales Beispiel, wie das in der Praxis aussieht:

import requests
from bs4 import BeautifulSoup

API_URL = "https://api.example.com/v1/scrape"
API_KEY = "your_api_key_here"

params = {
    "url": "https://www.amazon.com/s?k=usb+c+hub",
    "api_key": API_KEY,
    "render_js": "false",
}

response = requests.get(API_URL, params=params)
soup = BeautifulSoup(response.text, "lxml")
# Parse exactly as before
cards = soup.select('div[data-component-type="s-search-result"]')
print(f"Found {len(cards)} results via API")

Beachten Sie, dass sich Ihr Parsing-Code überhaupt nicht ändert. Der einzige Unterschied besteht in der Anfrage-URL und dem Hinzufügen eines API-Schlüssels. Das ist der Hauptvorteil: Sie entkoppeln das Abrufen vom Parsen und können zwischen selbst erstelltem Abruf und API-Abruf wechseln, ohne Ihre Extraktionslogik neu schreiben zu müssen.

Für Teams, die direkt strukturiertes JSON benötigen (und den HTML-Parsing-Schritt komplett überspringen möchten), bieten einige Dienste vorgefertigte Amazon-Scraper an, die Produkttitel, Preise und Bewertungen als gebrauchsfertige JSON-Felder zurückgeben.

Hier wird es interessant. Sobald Sie strukturierte Amazon-Produktdaten haben, können Sie diese direkt in Workflows mit großen Sprachmodellen einspeisen, um Zusammenfassungen, Vergleiche und Analysen durchzuführen, die manuell Stunden dauern würden.

Das einfachste Vorgehen besteht darin, Ihre gescrapten Daten in eine Markdown-Tabelle oder eine strukturierte Eingabeumgebung zu konvertieren und diese dann an eine LLM-API zu senden:

def build_prompt(products):
    lines = ["| Title | Price | Rating |", "|---|---|---|"]
    for p in products[:20]:
        lines.append(
            f"| {p['title'][:60]} | {p['price']} | {p['rating']} |"
        )
    table = "\n".join(lines)
    prompt = (
        "Below is a table of Amazon products. "
        "Summarize the price range, identify the top-rated option, "
        "and note any patterns in pricing vs. ratings.\n\n"
        f"{table}"
    )
    return prompt

Sie können JSON auch direkt als Kontext für eine RAG-Pipeline (Retrieval-Augmented Generation) einspeisen. Speichern Sie beispielsweise den gescrapten Produktkatalog in einem Vektorspeicher und lassen Sie Nutzer dann Fragen stellen wie „Welcher USB-C-Hub unter 30 Dollar hat die besten Bewertungen?“, um fundierte, datengestützte Antworten zu erhalten.

Ein paar praktische Tipps für LLM-fähige Amazon-Daten:

• Kürzen Sie Titel. Amazon-Produkttitel sind bekanntermaßen lang. Kürzen Sie sie auf 60 bis 80 Zeichen, um das Token-Budget einzuhalten.
• Normalisieren Sie Preise. Entfernen Sie Währungssymbole und konvertieren Sie die Werte in Fließkommazahlen, bevor Sie sie in analytische Prompts einspeisen.
• Batch-Anfragen. Wenn Sie Hunderte von Produkten haben, teilen Sie diese in Gruppen von 20 bis 30 pro Prompt auf, um Beschränkungen des Kontextfensters zu vermeiden.

Diese Kombination aus Web-Scraping und LLM-Analyse ist ein entscheidender Wettbewerbsvorteil für Teams, die Wettbewerbsanalysen oder die Extraktion von Amazon-Produktdaten in großem Maßstab durchführen.

Selbst mit einem soliden Scraper kann etwas schiefgehen. Hier sind die häufigsten Probleme, auf die Sie stoßen werden, wenn Sie Amazon-Produktseiten scrapen, und wie Sie diese beheben können.

403 Forbidden-Antworten. Dies bedeutet in der Regel, dass Amazons WAF Ihre Anfrage blockiert hat. Überprüfen Sie zunächst Ihren User-Agent Header. Falls dieser fehlt oder offensichtlich künstlich ist (wie python-requests/2.28), ersetzen Sie ihn durch eine realistische Browser-Zeichenkette. Wenn der 403-Fehler weiterhin auftritt, ist Ihre IP-Adresse wahrscheinlich gesperrt. Wechseln Sie zu einem Proxy oder fügen Sie eine längere Verzögerung zwischen den Anfragen ein.

CAPTCHA-Schleifen. Wenn jede Anfrage eine CAPTCHA-Seite anstelle von Produktergebnissen zurückgibt, wurde Ihre IP-Adresse oder Sitzung markiert. Der Wechsel zu einer neuen privaten IP-Adresse löst dieses Problem in der Regel. Es gibt programmgesteuerte CAPTCHA-Lösungsdienste, diese verursachen jedoch Latenz und zusätzliche Kosten.

Leere Selektoren (überall „None“-Werte). Dies deutet oft darauf hin, dass Amazon eine JavaScript-gerenderte Seite ausgeliefert hat und Ihr requests.get() Aufruf nur die vorgerenderte HTML-Hülle erfasst hat. Überprüfen Sie dies durch Ausgeben von len(response.text). Wenn die Antwort verdächtig kurz ist (unter 50 KB für eine Suchseite), treffen Sie wahrscheinlich auf ein JS-abhängiges Layout. Ein Headless-Browser oder eine Scraping-API mit JavaScript-Rendering kann dies beheben.

Veraltete Selektoren nach einer Layoutänderung. Amazon wechselt regelmäßig CSS-Klassen und DOM-Strukturen. Wenn ein Scraper, der letzte Woche noch funktionierte, plötzlich leere Daten zurückgibt, überprüfen Sie eine aktuelle Seite in DevTools und aktualisieren Sie Ihre Selektoren. Erstellen Sie Selektoren rund um data- (wie data-asin und data-component-type) ist robuster als das Verlassen auf Klassennamen.

• Legen Sie Ihren Ansatz frühzeitig fest. DIY-Python-Scraper bieten volle Kontrolle, Scraping-APIs reduzieren den Betriebsaufwand und No-Code-Tools eignen sich für Nicht-Entwickler. Passen Sie das Tool an die Fähigkeiten Ihres Teams und das Wartungsbudget an.
• Berücksichtigen Sie die Abwehrmaßnahmen von Amazon. Realistische Header, Request-Pacing und Proxy-Rotation sind kein Luxus. Wenn Sie darauf verzichten, werden Sie mehr Zeit mit der Fehlerbehebung bei Blockierungen verbringen als mit dem Schreiben von Parsing-Logik.
• Erstellen Sie Selektoren auf der Grundlage stabiler Attribute. Zielen Sie data-asin und data-component-type anstelle von volatilen Klassennamen. So funktioniert Ihr Scraper auch bei Amazons häufigen Layout-Aktualisierungen.
• Exportieren Sie frühzeitig und oft. Speichern Sie gescrapte Daten nach jedem Paginierungs-Batch als CSV oder JSON. Sollte eine spätere Anfrage fehlschlagen, verlieren Sie nicht alles, was Sie bereits gesammelt haben.
• Die LLM-Integration vervielfacht den Nutzen. Gescrapte Produktdaten werden deutlich nützlicher, wenn Sie sie in Zusammenfassungs-, Vergleichs- oder RAG-Workflows einspeisen.

Nein, nicht ausdrücklich. Die Nutzungsbedingungen von Amazon verbieten den automatisierten Zugriff auf die Website. Allerdings haben Gerichte in einigen Rechtsordnungen entschieden, dass das Scraping öffentlich zugänglicher Daten möglicherweise nicht gegen Gesetze zum Computerbetrug verstößt. Die Rechtslage ist nuanciert und variiert je nach Land. Konsultieren Sie daher einen Anwalt, wenn Sie planen, im kommerziellen Maßstab zu scrapen.

Verwenden Sie realistische Browser-Header (insbesondere User-Agent), fügen Sie Verzögerungen von mindestens 1 bis 2 Sekunden zwischen den Anfragen ein und wechseln Sie die IP-Adressen mithilfe eines Pools privater Proxys. Vermeiden Sie es, in schnellen Bursts von einer einzigen IP-Adresse aus zu scrapen, und erwägen Sie, Ihre Anfrageintervalle zu randomisieren, um menschliche Surfgewohnheiten nachzuahmen.

Ja. Mehrere visuelle Scraping-Plattformen bieten Point-and-Click-Oberflächen mit vorgefertigten Amazon-Vorlagen. Sie konfigurieren Selektoren über eine Browser-Erweiterung oder eine Web-Benutzeroberfläche, und das Tool übernimmt die Anforderungsverwaltung und den Datenexport. Diese Optionen eignen sich am besten für kleinere, ad-hoc-Datenabfragen und weniger für groß angelegte automatisierte Pipelines.

Requests und BeautifulSoup sind die Standardkombination für das Scraping statischer HTML-Seiten. Fügen Sie lxml als Parser-Backend hinzu, um die Verarbeitung zu beschleunigen. Für Seiten, die stark auf JavaScript-Rendering angewiesen sind, eignen sich Playwright oder Selenium mit einem Headless-Browser besser. pandas ist auf der Exportseite nützlich, um die gesammelten Daten zu bereinigen und zu strukturieren.

Das Scraping von Amazon-Produktdaten ist eines jener Projekte, die auf dem Papier einfach klingen, aber schnell kompliziert werden. Das Parsen selbst ist unkompliziert: Sobald man die richtigen CSS-Selektoren kennt, erledigt BeautifulSoup die Hauptarbeit mit wenigen Zeilen Code. Die eigentliche Herausforderung liegt in allem, was das Parsen umgibt: eine saubere Antwort an Amazons Anti-Bot-Stack vorbeizubekommen, die Paginierung zu handhaben, ohne dass die eigene IP-Adresse markiert wird, und die Selektoren auf dem neuesten Stand zu halten, während sich die Plattform weiterentwickelt.

Der in diesem Leitfaden behandelte Python-Workflow bietet Ihnen eine solide Grundlage. Sie können Suchergebnisse abrufen, Titel, Preise, Bewertungen, Bilder und ASINs extrahieren, über mehrere Seiten hinweg paginieren, saubere CSV- oder JSON-Dateien exportieren und diese Daten sogar in LLM-Pipelines für die automatisierte Analyse einspeisen. Für kleinere einmalige Projekte reicht dieser DIY-Ansatz möglicherweise völlig aus.

Bei Produktions-Workloads, bei denen die Verfügbarkeit entscheidend ist, sollten Sie in Betracht ziehen, die Anforderungsschicht an einen Dienst wie WebScrapingAPI auszulagern. Dieser übernimmt die Proxy-Rotation, das Lösen von CAPTCHAs und die Wiederholungslogik hinter einem einzigen Endpunkt, sodass Sie sich auf die Daten statt auf die Infrastruktur konzentrieren können. Ihr BeautifulSoup-Parsing-Code bleibt genau derselbe; nur der Abrufschritt ändert sich.

Welchen Weg Sie auch wählen, entscheidend ist, mit einem klaren Plan zu beginnen: Definieren Sie, welche Produktattribute Sie benötigen, legen Sie Ihr Exportformat fest und integrieren Sie von Anfang an eine Fehlerbehandlung. Der Amazon-Katalog ist eine Goldgrube an strukturierten Daten, wenn Sie methodisch vorgehen.