Amazon-Scraper mit Python: Anleitung zur Extraktion von Produktdaten

Hand aufs Herz: Amazon ist das Online-Shopping-Mekka schlechthin – egal ob du im Vertrieb, E-Commerce oder in der Logistik unterwegs bist, was auf Amazon passiert, hat direkte Auswirkungen auf deine Preise, Lagerbestände und sogar auf den nächsten Produkt-Launch. Das Problem dabei? Die ganzen spannenden Infos zu Produkten, Preisen, Bewertungen und Rezensionen sind hinter einer Oberfläche versteckt, die für Käufer gemacht ist – nicht für datenhungrige Teams. Wie kommst du also an diese Daten, ohne stundenlang Copy & Paste zu machen?

Hier kommt Web Scraping ins Spiel. In diesem Guide zeige ich dir zwei Wege, wie du Amazon-Produktdaten abgreifen kannst: Einmal klassisch mit Python-Code und einmal super easy mit einer modernen, KI-gestützten No-Code-Lösung wie dem Web-Scraper . Ich führe dich durch echten Python-Code (inklusive aller Stolperfallen) und zeige dir dann, wie du mit Thunderbit die gleichen Daten in wenigen Klicks – ganz ohne Programmieren – bekommst. Egal ob du Entwickler bist, Business Analyst oder einfach keine Lust mehr auf Handarbeit hast: Hier findest du die passende Lösung.

Warum Amazon-Produktdaten extrahieren? (amazon scraper python, web scraping mit python)

Amazon ist nicht nur der größte Online-Händler der Welt, sondern auch eine riesige Fundgrube für Markt- und Wettbewerbsanalysen. Mit und ist Amazon eine Goldgrube für alle, die:

• Preise überwachen (und die eigenen in Echtzeit anpassen)
• Wettbewerber analysieren (neue Produkte, Bewertungen und Rezensionen im Blick behalten)
• Leads generieren (Verkäufer, Lieferanten oder potenzielle Partner finden)
• Nachfrage prognostizieren (Lagerbestände und Verkaufsränge beobachten)
• Trends erkennen (durch Auswertung von Rezensionen und Suchergebnissen)

Das ist nicht nur graue Theorie – Unternehmen holen sich damit echten Mehrwert. Ein Elektronikhändler konnte mit Amazon-Preisdaten , eine andere Marke erreichte durch automatisiertes Preis-Monitoring.

Hier eine Übersicht typischer Anwendungsfälle und des zu erwartenden Nutzens:

Und das Beste: berichten inzwischen von messbarem Mehrwert durch Datenanalysen. Wer Amazon nicht ausliest, verschenkt wertvolle Insights – und bares Geld.

Überblick: Amazon Scraper Python vs. No Code Web Scraper Tools

Es gibt zwei Hauptwege, wie du Amazon-Daten aus dem Browser in deine Tabellen oder Dashboards bekommst:

1. Amazon Scraper Python (web scraping mit python):

   Du schreibst ein eigenes Skript mit Python-Bibliotheken wie Requests und BeautifulSoup. Das gibt dir maximale Kontrolle, erfordert aber Programmierkenntnisse, den Umgang mit Anti-Bot-Maßnahmen und regelmäßige Wartung, wenn Amazon die Seite ändert.

2. No Code Web Scraper Tools (wie Thunderbit):

   Du nutzt ein Tool, das per Klick Daten extrahiert – ganz ohne Programmierung. Moderne Tools wie setzen sogar KI ein, um relevante Daten zu erkennen, Unterseiten und Paginierung zu verarbeiten und direkt nach Excel oder Google Sheets zu exportieren.

So schneiden beide Ansätze im Vergleich ab:

Im Folgenden zeige ich dir beide Wege – zuerst, wie du einen Amazon-Scraper in Python baust, dann wie du mit Thunderbit und KI in Minuten zum Ziel kommst.

Einstieg: Amazon Scraper Python – Voraussetzungen & Setup

Bevor du loslegst, richte deine Umgebung ein.

Du brauchst:

• Python 3.x (Download von )
• Einen Code-Editor (z. B. VS Code, aber jeder andere geht auch)
• Diese Bibliotheken:
  • requests (für HTTP-Anfragen)
  • beautifulsoup4 (zum Parsen von HTML)
  • lxml (schneller HTML-Parser)
  • pandas (für Tabellen/Export)
  • re (Reguläre Ausdrücke, Standardbibliothek)

Installation der Bibliotheken:

1pip install requests beautifulsoup4 lxml pandas

Projekt-Setup:

• Lege einen neuen Ordner für dein Projekt an.
• Öffne deinen Editor und erstelle eine neue Python-Datei (z. B. amazon_scraper.py).
• Los geht’s!

Schritt für Schritt: Web Scraping mit Python für Amazon-Produktdaten

Wir starten mit dem Scraping einer einzelnen Produktseite. (Keine Sorge, gleich geht’s auch um mehrere Produkte und Seiten.)

1. Anfrage senden und HTML abrufen

Zuerst holen wir das HTML einer Produktseite. (URL bitte durch ein beliebiges Amazon-Produkt ersetzen.)

1import requests
2url = "<https://www.amazon.com/dp/B0ExampleASIN>"
3response = requests.get(url)
4html_content = response.text
5print(response.status_code)

Achtung: Diese einfache Anfrage wird von Amazon meist blockiert. Statt der Produktseite bekommst du oft einen 503-Fehler oder ein CAPTCHA. Warum? Amazon erkennt, dass du kein echter Browser bist.

So umgehst du Amazons Anti-Bot-Schutz

Amazon mag keine Bots. Um nicht geblockt zu werden, solltest du:

• Einen User-Agent-Header setzen (Browser wie Chrome oder Firefox vortäuschen)
• User-Agents rotieren (nicht immer denselben verwenden)
• Anfragen verzögern (zufällige Pausen einbauen)
• Proxies nutzen (bei großem Umfang)

So setzt du die Header:

1headers = {
2    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)... Safari/537.36",
3    "Accept-Language": "en-US,en;q=0.9",
4}
5response = requests.get(url, headers=headers)

Für Fortgeschrittene: Nutze eine Liste von User-Agents und rotiere sie. Bei größeren Projekten empfiehlt sich ein Proxy-Service, für kleine Scrapes reichen Header und Pausen meist aus.

Wichtige Produktdaten extrahieren

Jetzt wird das HTML mit BeautifulSoup geparst.

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(html_content, "lxml")

Nun holen wir uns die wichtigsten Infos:

Produkttitel

1title_elem = soup.find(id="productTitle")
2product_title = title_elem.get_text(strip=True) if title_elem else None

Preis

Amazon zeigt Preise an verschiedenen Stellen. Probiere Folgendes:

1price = None
2price_elem = soup.find(id="priceblock_ourprice") or soup.find(id="priceblock_dealprice")
3if price_elem:
4    price = price_elem.get_text(strip=True)
5else:
6    price_whole = soup.find("span", {"class": "a-price-whole"})
7    price_frac = soup.find("span", {"class": "a-price-fraction"})
8    if price_whole and price_frac:
9        price = price_whole.text + price_frac.text

Bewertung und Anzahl der Rezensionen

1rating_elem = soup.find("span", {"class": "a-icon-alt"})
2rating = rating_elem.get_text(strip=True) if rating_elem else None
3review_count_elem = soup.find(id="acrCustomerReviewText")
4reviews_text = review_count_elem.get_text(strip=True) if review_count_elem else ""
5reviews_count = reviews_text.split()[0]  # z. B. "1.554 Bewertungen"

Hauptbild-URL

Amazon versteckt hochauflösende Bilder manchmal im HTML-JSON. Ein schneller Regex-Ansatz:

1import re
2match = re.search(r'"hiRes":"(https://.*?.jpg)"', html_content)
3main_image_url = match.group(1) if match else None

Oder das Hauptbild direkt holen:

1img_tag = soup.find("img", {"id": "landingImage"})
2img_url = img_tag['src'] if img_tag else None

Produktdetails

Spezifikationen wie Marke, Gewicht und Maße stehen meist in einer Tabelle:

1details = {}
2rows = soup.select("#productDetails_techSpec_section_1 tr")
3for row in rows:
4    header = row.find("th").get_text(strip=True)
5    value = row.find("td").get_text(strip=True)
6    details[header] = value

Oder, falls Amazon das „detailBullets“-Format nutzt:

1bullets = soup.select("#detailBullets_feature_div li")
2for li in bullets:
3    txt = li.get_text(" ", strip=True)
4    if ":" in txt:
5        key, val = txt.split(":", 1)
6        details[key.strip()] = val.strip()

Ergebnisse ausgeben:

1print("Titel:", product_title)
2print("Preis:", price)
3print("Bewertung:", rating, "bei", reviews_count, "Rezensionen")
4print("Hauptbild-URL:", main_image_url)
5print("Details:", details)

Mehrere Produkte und Paginierung scrapen

Ein Produkt ist nett, aber meist willst du eine ganze Liste. So holst du Produktlinks aus einer Suchseite:

1search_url = "<https://www.amazon.com/s?k=bluetooth+headphones>"
2res = requests.get(search_url, headers=headers)
3soup = BeautifulSoup(res.text, "lxml")
4product_links = []
5for a in soup.select("h2 a.a-link-normal"):
6    href = a['href']
7    full_url = "<https://www.amazon.com>" + href
8    product_links.append(full_url)

Paginierung verarbeiten

Amazon-Suchergebnisse nutzen &page=2, &page=3 usw.

1for page in range(1, 6):  # erste 5 Seiten scrapen
2    search_url = f"<https://www.amazon.com/s?k=bluetooth+headphones&page={page}>"
3    res = requests.get(search_url, headers=headers)
4    if res.status_code != 200:
5        break
6    soup = BeautifulSoup(res.text, "lxml")
7    # ... Produktlinks wie oben extrahieren ...

Produktdaten sammeln und als CSV exportieren

Sammle die Daten in einer Liste von Dictionaries und exportiere sie mit pandas:

1import pandas as pd
2df = pd.DataFrame(product_data_list)  # Liste von Dicts
3df.to_csv("amazon_products.csv", index=False)

Oder als Excel-Datei:

1df.to_excel("amazon_products.xlsx", index=False)

Best Practices für Amazon Scraper Python-Projekte

Amazon ändert ständig die Seite und schützt sich aktiv vor Scraping. So bleibt dein Projekt stabil:

• Headers und User-Agents rotieren (z. B. mit fake-useragent)
• Proxies nutzen bei großem Umfang
• Anfragen verzögern (zufällige time.sleep()-Pausen)
• Fehler abfangen (bei 503 neu versuchen, bei Blockierung pausieren)
• Flexibles Parsing (mehrere Selektoren pro Feld prüfen)
• HTML-Änderungen überwachen (wenn plötzlich alles None ist, Seite prüfen)
• robots.txt respektieren (Amazon verbietet Scraping vieler Bereiche – handle verantwortungsvoll)
• Daten direkt bereinigen (Währungszeichen, Kommas, Leerzeichen entfernen)
• Community nutzen (Foren, Stack Overflow, Reddit r/webscraping)

Checkliste für die Wartung deines Scrapers:

• [ ] User-Agents und Header rotieren
• [ ] Proxies bei großem Umfang einsetzen
• [ ] Zufällige Pausen einbauen
• [ ] Code modular halten
• [ ] Auf Sperren oder CAPTCHAs achten
• [ ] Daten regelmäßig exportieren
• [ ] Selektoren und Logik dokumentieren

Mehr dazu findest du in meinem .

Die No-Code-Alternative: Amazon mit Thunderbit KI-Web-Scraper auslesen

Du hast den Python-Weg gesehen. Aber was, wenn du nicht programmieren willst – oder die Daten einfach in zwei Klicks brauchst? Genau dafür gibt es .

Thunderbit ist eine KI-Web-Scraper Chrome Extension, mit der du Amazon-Produktdaten (und Daten von fast jeder Website) ohne eine Zeile Code extrahierst. Das macht Thunderbit besonders:

• KI-Feldvorschläge: Ein Klick, und Thunderbits KI erkennt automatisch relevante Datenfelder (z. B. Titel, Preis, Bewertung).
• Sofortige Daten-Templates: Für Amazon gibt es eine fertige Vorlage, die alle Standardfelder abdeckt – kein Setup nötig.
• Unterseiten-Scraping: Du kannst eine Produktliste scrapen und Thunderbit besucht automatisch jede Detailseite für weitere Infos.
• Paginierung: Thunderbit klickt für dich durch „Nächste“-Seiten oder endloses Scrollen.
• Export zu Excel, Google Sheets, Airtable, Notion: Ein Klick, und deine Daten sind einsatzbereit.
• Kostenlose Version: Teste mit einigen Seiten gratis.
• Anti-Bot-Handling inklusive: Da Thunderbit im Browser (oder in der Cloud) läuft, sieht Amazon dich als echten Nutzer.

Schritt für Schritt: Mit Thunderbit Amazon-Produktdaten scrapen

So einfach geht’s:

1. Thunderbit installieren:

   Lade die herunter und melde dich an.

2. Amazon öffnen:

   Gehe auf die gewünschte Amazon-Seite (Suchergebnisse, Produktdetail, etc.).

3. „KI-Felder vorschlagen“ oder Vorlage wählen:

   Thunderbit schlägt dir automatisch passende Spalten vor (oder du nutzt die Amazon-Produktvorlage).

4. Spalten prüfen:

   Passe die Spalten nach Bedarf an (hinzufügen, entfernen, umbenennen).

5. Auf „Scrapen“ klicken:

   Thunderbit extrahiert die Daten und zeigt sie in einer Tabelle an.

6. Unterseiten & Paginierung nutzen:

   Bei Listen kannst du „Unterseiten scrapen“ wählen, damit Thunderbit jede Produktdetailseite besucht. Auch das automatische Durchklicken von Seiten ist möglich.

7. Daten exportieren:

   Klicke auf „Export zu Excel“ oder „Export zu Google Sheets“. Fertig.

8. (Optional) Scraping planen:

   Du brauchst die Daten regelmäßig? Mit dem Thunderbit-Scheduler kannst du das automatisieren.

Das war’s. Kein Code, kein Debugging, keine Proxies, kein Stress. Für eine visuelle Anleitung schau auf dem oder auf der vorbei.

Amazon Scraper Python vs. No Code Web Scraper: Direktvergleich

Hier der direkte Vergleich:

Wenn du Entwickler bist und maximale Anpassung brauchst, ist Python dein Werkzeug. Für Geschwindigkeit, Einfachheit und null Code ist Thunderbit die beste Wahl.

Wann Python, No Code oder KI-Web-Scraper für Amazon-Daten nutzen?

Python eignet sich, wenn:

• Du individuelle Logik brauchst oder Scraping in Backend-Systeme integrieren willst
• Du sehr große Datenmengen (zehntausende Produkte) verarbeiten möchtest
• Du verstehen willst, wie Scraping technisch funktioniert

Thunderbit (No Code, KI-Web-Scraper) ist ideal, wenn:

• Du Daten schnell und ohne Programmierung brauchst
• Du Business-User, Analyst oder Marketer bist
• Dein Team eigenständig Daten beschaffen soll
• Du keine Lust auf Proxies, Anti-Bot-Maßnahmen und Wartung hast

Beides kombinieren, wenn:

• Du mit Thunderbit schnell prototypen und später eine individuelle Python-Lösung bauen willst
• Du Thunderbit für die Datensammlung und Python für die Analyse/Bereinigung nutzt

Für die meisten Business-Anwendungen deckt Thunderbit 90 % der Amazon-Scraping-Bedürfnisse in einem Bruchteil der Zeit ab. Für die restlichen 10 % – also sehr spezielle, groß angelegte oder tief integrierte Projekte – bleibt Python unschlagbar.

Fazit & wichtigste Erkenntnisse

Das Extrahieren von Amazon-Produktdaten ist ein echter Wettbewerbsvorteil für Vertrieb, E-Commerce und Operations. Egal ob Preisüberwachung, Wettbewerbsanalyse oder einfach weniger Copy & Paste – es gibt für jeden die passende Lösung.

• Python-Scraping bietet maximale Kontrolle, erfordert aber Know-how und Wartung.
• No Code Web-Scraper wie Thunderbit machen Amazon-Daten für alle zugänglich – ohne Programmierung, ohne Kopfschmerzen, mit schnellen Ergebnissen.
• Die beste Lösung? Nutze das Tool, das zu deinen Fähigkeiten, deinem Zeitplan und deinen Zielen passt.

Neugierig? Probiere Thunderbit aus – der Einstieg ist kostenlos und du wirst überrascht sein, wie schnell du an die gewünschten Daten kommst. Und als Entwickler kannst du beide Ansätze kombinieren: Oft ist der schnellste Weg, die KI die Routinearbeit erledigen zu lassen.

Häufige Fragen (FAQ)

1. Warum sollten Unternehmen Amazon-Produktdaten scrapen?

Durch das Scrapen von Amazon können Unternehmen Preise überwachen, Wettbewerber analysieren, Rezensionen für Produktentwicklung nutzen, Nachfrage prognostizieren und Leads generieren. Mit über 600 Millionen Produkten und fast 2 Millionen Verkäufern ist Amazon eine wertvolle Quelle für Marktinformationen.

2. Was sind die Hauptunterschiede zwischen Python und No-Code-Tools wie Thunderbit beim Amazon-Scraping?

Python-Scraper bieten maximale Flexibilität, erfordern aber Programmierkenntnisse, Setup und Wartung. Thunderbit als No-Code KI-Web-Scraper ermöglicht das Extrahieren von Amazon-Daten direkt per Chrome-Extension – ohne Programmierung, mit integriertem Anti-Bot-Schutz und Export zu Excel oder Sheets.

3. Ist das Scrapen von Amazon-Daten legal?

Amazons Nutzungsbedingungen verbieten Scraping grundsätzlich und setzen Anti-Bot-Maßnahmen ein. Viele Unternehmen extrahieren dennoch öffentlich zugängliche Daten, achten aber auf verantwortungsvolles Vorgehen (z. B. keine Überlastung durch zu viele Anfragen).

4. Welche Daten kann ich mit Web-Scraping-Tools von Amazon extrahieren?

Typische Felder sind Produkttitel, Preise, Bewertungen, Anzahl der Rezensionen, Bilder, Produktspezifikationen, Verfügbarkeit und Verkäuferinfos. Thunderbit unterstützt auch das Scrapen von Unterseiten und Paginierung für mehrere Listings und Seiten.

5. Wann sollte ich Python-Scraping statt eines Tools wie Thunderbit nutzen (oder umgekehrt)?

Python ist ideal, wenn du volle Kontrolle, individuelle Logik oder Backend-Integration brauchst. Thunderbit eignet sich, wenn du schnelle Ergebnisse ohne Programmierung, einfache Skalierung oder eine wartungsarme Lösung für Business-User suchst.

Mehr Infos findest du hier:

Viel Erfolg beim Scrapen – und auf stets aktuelle Tabellen!