Amazon-Bestseller scrapenTop-Produkte nach Kategorie

Amazons Bestseller-Seiten sind ein Live-Ranking der tatsächlich meistverkauften Produkte im gesamten Katalog. Jede Kategorie, von Elektronik bis Computer und Zubehör, hat ihre eigene geordnete Liste der Top-Produkte, die von Amazon stündlich aktualisiert wird. Jeder Artikel zeigt Rang, Titel, Preis und Bewertung direkt auf der Seite. Dieses Ranking ist eines der saubersten Nachfragesignale im offenen Web, weshalb Produktforscher, Verkäufer und Analysten es für Trendbeobachtung, Wettbewerbsanalyse und Preisentscheidungen verfolgen.

Diese Anleitung zeigt Ihnen, wie Sie eine Amazon-Bestsellerliste mit Python scrapen. Sie entwickeln einen kleinen, lauffähigen Scraper, der die Bestseller-Seite einer Kategorie über die Crawling API abruft, einen sauberen Datensatz für jedes gerankte Produkt parst und die Ergebnisse nach JSON und CSV exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche Ranking-Daten: die Namen, Preise, Bewertungen und Links, die jeder auf einer Bestseller-Seite ohne Anmeldung sehen kann.

Was Sie entwickeln werden

Ein Python-Skript, das eine Amazon-Bestseller-Kategorie-URL entgegennimmt, die gerenderte Seite über die Crawling API abruft und einen strukturierten Datensatz pro geranketem Produkt extrahiert. Als laufendes Beispiel verwenden wir die Seite Bestseller in Computer und Zubehör, dieselbe Kategorie wie das frühere Walkthrough, und lesen folgende Felder aus jeder Ranking-Karte:

• Rang die Position des Produkts in der Liste, zum Beispiel 1 für den Topverkäufer.
• Titel der Produktname, der auf der Ranking-Karte angezeigt wird.
• Preis der angegebene Preis, wenn das Produkt einen zeigt.
• Bewertung die durchschnittliche Sternebewertung, zum Beispiel „4,7 von 5 Sternen".
• Link die URL zur eigenen Detailseite des Produkts.

Warum eine einfache Anfrage bei Amazon scheitert

Wenn Sie einen einfachen HTTP-Client auf eine Amazon-Bestseller-URL richten, erhalten Sie selten die gesuchte Rangliste. Zwei Faktoren arbeiten gegen Sie. Erstens rendert ein Großteil des Ranking-Grids clientseitig: Amazon liefert eine leichte Hülle und füllt die Karten, während die JavaScript-Seite läuft und Sie scrollen, sodass dem initialen HTML häufig die niedriger gerandkten Artikel fehlen. Zweitens erkennt Amazon automatisierten Datenverkehr schnell. Rechenzentrum-IP-Bereiche und Anfragemuster, die nicht wie ein echter Browser aussehen, werden mit einem CAPTCHA, einer „Robot Check"-Zwischenseite oder einer vollständigen Blockierung konfrontiert, bevor Sie die Liste erreichen.

Ein funktionierender Bestseller-Scraper benötigt also zwei Dinge in einer Anfrage: einen Browser, der die Seite rendert, und eine IP, die Amazon als echten Käufer liest. Das lässt sich zwar selbst mit einem Headless-Browser und einem Pool rotierender Residential-Proxies zusammenstellen, aber deren Aufrechterhaltung ist der Großteil der Arbeit. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie senden ihr die Kategorie-URL, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP, verwaltet die Rotation und das CAPTCHA-Lösen und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Bevor Sie mit dem Programmieren beginnen, müssen einige Dinge vorbereitet sein. Keines davon nimmt viel Zeit in Anspruch.

Python-Grundkenntnisse. Sie sollten mit dem Schreiben und Ausführen von Python-Skripten sowie der Installation von Paketen mit pip vertraut sein. Wenn Sie neu in der Sprache sind, decken die offiziellen Python-Dokumentationen oder ein Einsteigerkurs das Niveau ab, das dieses Tutorial voraussetzt.

Python 3.8 oder höher. Überprüfen Sie Ihre Version mit python --version (oder python3 --version). Falls Sie es noch nicht installiert haben, laden Sie es von python.org herunter und stellen Sie sicher, dass Python in Ihrem System-PATH steht.

Ein Crawlbase-Konto und Token. Melden Sie sich für ein kostenloses Konto an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token von der Kontodokumentationsseite. Der kostenlose Tarif enthält bis zu 20.000 Anfragen ohne Kreditkarte, was mehr als genug ist, um diesen Scraper zu entwickeln und zu testen. Behandeln Sie das Token wie ein Passwort und halten Sie es aus der Versionskontrolle fern.

Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die beiden Bibliotheken, die der Scraper benötigt. crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie jedes Feld per CSS-Selector aus den Ranking-Karten extrahieren können.

python --version

python -m venv amazon_env
source amazon_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit amazon_env\Scripts\activate anstelle der source-Zeile. Mit beiden installierten Bibliotheken erstellen Sie die Skriptdatei, die der Rest der Anleitung aufbaut:

touch amazon_best_sellers.py

Die Bestseller-Seite verstehen

Jede Amazon-Bestseller-Kategorie hat eine stabile /zgbs/-URL. Die Liste für Computer und Zubehör ist zum Beispiel https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc, und Elektronik ist https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics. Die Seite legt ein geordnetes Raster von Ranking-Karten an, eine pro Produkt, jede mit denselben wenigen Feldern: einem Rang-Badge, einem Titel, einem Preis, einer Sternebewertung und einem Link zur Detailseite des Produkts.

Bevor Sie Selectors schreiben, öffnen Sie eine Bestseller-Seite in Ihrem Browser, klicken Sie mit der rechten Maustaste auf eine Ranking-Karte und wählen Sie Untersuchen. Amazon umschließt jedes gerankte Element in einem Container, der mit einem Attribut id="gridItemRoot" markiert ist, zeigt den Rang in einem nummerierten Badge oben auf der Karte und stellt Titel, Preis und Bewertung innerhalb dieses Containers zur Verfügung. Das sind die Elemente, auf die Sie abzielen. Amazons Utility-Klassennamen ändern sich häufig, bevorzugen Sie also, wo möglich, die dauerhafteren strukturellen Attribute wie id="gridItemRoot" statt einer fragilen Klassenkette.

Schritt 1: Die gerenderte Bestseller-Seite abrufen

Beginnen Sie mit dem Abruf der fertigen Seite. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token, setzen Sie die Kategorie-URL und fordern Sie sie an. Die Überprüfung des Statuscodes vor dem Parsen sorgt dafür, dass Fehler auffallen statt still zu scheitern.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 4000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    bestsellers_url = "https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc"
    html = crawl(bestsellers_url)
    print(html[:500] if html else "No HTML returned")

Die beiden Wait-Optionen sind bei einer Liste, die sich beim Laden der Seite befüllt, wichtig. ajax_wait weist die API an, auf den Abschluss asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl Millisekunden nach dem Laden inne, sodass die spät gerenderten Karten erscheinen, bevor die Seite erfasst wird. Der Body wird als latin1 dekodiert, da Amazon-Seiten Zeichen einmischen, an denen eine strenge UTF-8-Dekodierung scheitern kann. Führen Sie das Skript aus, und Sie sollten echtes Ranking-Markup sehen, keine Robot-Check-Hülle. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selector schreiben.

Schritt 2: Ranking-Karten mit BeautifulSoup parsen

Mit dem gerenderten HTML laden Sie es in BeautifulSoup, finden jede Ranking-Karte und extrahieren jedes Feld anhand seines Selectors. Amazon umschließt jedes gerankte Element in einem Container, auf den Sie selektieren, zeigt den Rang in einem nummerierten Badge und stellt Titel, Preis und Bewertung innerhalb der Karte bereit. Lesen Sie den Produktlink aus dem Anker der Karte. Kapseln Sie jede Karte in einem try/except, damit ein fehlerhaftes Angebot den Lauf nicht zum Absturz bringt.

from bs4 import BeautifulSoup

BASE = "https://www.amazon.com"

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

def parse_link(card):
    a = card.select_one("a.a-link-normal[href]")
    if not a:
        return None
    href = a["href"]
    return href if href.startswith("http") else BASE + href

def scrape_best_sellers(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div#gridItemRoot")
    results = []
    for card in cards:
        try:
            rank = text_of(card, "span.zg-bdg-text")
            results.append({
                "rank": rank.lstrip("#") if rank else None,
                "title": text_of(card, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1"),
                "price": text_of(card, "span._cDEzb_p13n-sc-price_3mJ9Z"),
                "rating": text_of(card, "span.a-icon-alt"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

Der Helper text_of fragt ein Element innerhalb einer Karte ab und gibt None zurück, wenn es fehlt, anstatt bei einem .get_text()-Aufruf auf nichts zu werfen. Das macht die Extraktion robust, wenn ein Feld fehlt, was häufig vorkommt, da nicht jedes gerankte Element einen Preis zeigt. Der Rang kommt aus dem nummerierten Badge (span.zg-bdg-text), mit dem führenden # entfernt, damit Sie eine saubere Zahl speichern. Der Bewertungsstring steht im versteckten span.a-icon-alt, der den „4,7 von 5 Sternen"-Text enthält, den Amazon hinter der Sterngrafik rendert, und der Link wird auf eine absolute URL normalisiert, da Amazon häufig einen relativen href liefert.

Schritt 3: Skript zusammenstellen und JSON und CSV exportieren

Verbinden Sie jetzt den Abruf und das Parsen zu einem lauffähigen Skript und schreiben Sie dann die Datensätze sowohl als JSON als auch als CSV, damit Sie sie in ein Notebook oder eine Tabellenkalkulation laden können. Rufen Sie die gerenderte Kategorieseite ab, übergeben Sie sie an den Parser und geben Sie die strukturierten Zeilen aus.

import csv
import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.amazon.com"
FIELDS = ["rank", "title", "price", "rating", "link"]

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 4000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("latin1")
    print(f"Request failed: {response['status_code']}")
    return None

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

def parse_link(card):
    a = card.select_one("a.a-link-normal[href]")
    if not a:
        return None
    href = a["href"]
    return href if href.startswith("http") else BASE + href

def scrape_best_sellers(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div#gridItemRoot")
    results = []
    for card in cards:
        try:
            rank = text_of(card, "span.zg-bdg-text")
            results.append({
                "rank": rank.lstrip("#") if rank else None,
                "title": text_of(card, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1"),
                "price": text_of(card, "span._cDEzb_p13n-sc-price_3mJ9Z"),
                "rating": text_of(card, "span.a-icon-alt"),
                "link": parse_link(card),
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def export(rows, name="amazon_best_sellers"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} products to {name}.json and {name}.csv")

def main():
    url = "https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc"
    html = crawl(url)
    if not html:
        return
    rows = scrape_best_sellers(html)
    export(rows)

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python amazon_best_sellers.py aus. Es ruft die gerenderte Kategorieseite ab, parst eine Zeile pro geranketem Produkt und schreibt sowohl amazon_best_sellers.json als auch amazon_best_sellers.csv. Die gemeinsame Liste FIELDS hält die CSV-Spaltenreihenfolge mit den Dictionary-Schlüsseln in Einklang, sodass die beiden Exporte nie auseinanderdriften.

Wie die Ausgabe aussieht

Sie erhalten eine saubere Liste gerandkter Datensätze in Listenreihenfolge, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

[
  {
    "rank": "1",
    "title": "Amazon Basics High-Speed HDMI Cable, 6 Feet",
    "price": "$6.99",
    "rating": "4.7 out of 5 stars",
    "link": "https://www.amazon.com/dp/B014I8SSD0"
  },
  {
    "rank": "2",
    "title": "Apple AirTag",
    "price": "$24.99",
    "rating": "4.7 out of 5 stars",
    "link": "https://www.amazon.com/dp/B0D54JZTHY"
  }
]

Schnellerer Weg: der integrierte Bestseller-Scraper

Eigene Selectors zu schreiben gibt Ihnen volle Kontrolle, bedeutet aber auch, diese zu pflegen, wenn sich Amazons Markup verschiebt. Wenn Sie das lieber vermeiden möchten, liefert die Crawling API einen integrierten amazon-best-sellers-Scraper, der die Rangliste direkt als strukturiertes JSON zurückgibt, ohne BeautifulSoup zu benötigen. Sie übergeben eine scraper-Option und lesen den geparsten body.

import json
from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics"

response = api.get(url, {"scraper": "amazon-best-sellers"})

if response.get("status_code") == 200:
    data = json.loads(response["body"].decode("latin1"))
    result = data.get("body", {})
    with open("amazon_best_sellers.json", "w", encoding="utf-8") as f:
        json.dump(result, f, indent=4, ensure_ascii=False)
    print("Scraper response saved to amazon_best_sellers.json")
else:
    print(f"Request failed: {response.get('status_code', 0)}")

Die geparste Antwort enthält einen pageTitle, ein products-Array (jedes mit title, price, customerReview, customerReviewCount, asin, image, url und position), die Liste der Geschwister-categories und einen pagination-Block. Es ist der schnellste Weg zu einem gepflegten Ranking-Feed; der oben erstellte handgeschriebene Parser ist die richtige Wahl, wenn Sie Felder benötigen, die der integrierte Scraper nicht zurückgibt, oder wenn Sie die Seitenstruktur kennenlernen möchten. Die in Auto-Parse Web Data dokumentierte Scraper API treibt dasselbe Auto-Parsing an.

Skalierung über Kategorien und Seiten hinweg

Eine Kategorie ist eine Demo; ein echter Recherche-Auftrag läuft über viele. Amazon stellt für fast jede Abteilung und Unterkategorie eine Bestsellerliste bereit, jede unter ihrer eigenen /zgbs/-URL, und jede Liste paginiert (typischerweise die Top 50 aufgeteilt über zwei Seiten, mit einem Parameter ?pg=2). Durchlaufen Sie eine Reihe von Kategorie-URLs und dosieren Sie die Anfragen, damit Sie Amazon nicht in einer engen Schleife überllasten.

import time

CATEGORIES = {
    "computers": "https://www.amazon.com/Best-Sellers-Computers-Accessories/zgbs/pc",
    "electronics": "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics",
}

def scrape_categories(categories):
    everything = {}
    for name, url in categories.items():
        rows = []
        for page in (1, 2):
            page_url = url if page == 1 else f"{url}?pg={page}"
            html = crawl(page_url)
            if not html:
                break
            found = scrape_best_sellers(html)
            if not found:
                break
            rows.extend(found)
            print(f"{name} page {page}: {len(found)} products")
            time.sleep(2)
        everything[name] = rows
    return everything

Der Leerergebnis-Break stoppt Sie frühzeitig, wenn einer Kategorie die Seiten ausgehen, und das time.sleep(2) zwischen Anfragen dosiert den Lauf, damit Sie nicht für schnellen Datenverkehr markiert werden. Die Ausgabe nach Kategoriename zu schlüsseln hält jede Liste getrennt, was genau das ist, was Sie beim Vergleich von Rankings zwischen Abteilungen wollen. Um Trends im Laufe der Zeit zu verfolgen, führen Sie den Auftrag nach einem Zeitplan aus und stempeln Sie jeden Export mit dem Datum, dann vergleichen Sie aufeinanderfolgende Snapshots, um zu sehen, was in der Liste gestiegen oder gefallen ist.

Nicht geblockt bleiben

Auch mit gehandhabtem Rendering beobachtet Amazon scraper-ähnlichen Datenverkehr. Ein paar Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes schwere kommerzielle Ziel.

• Anfragen dosieren. Verteilen Sie Anfragen mit einer Verzögerung zwischen Seiten und Kategorien, anstatt alles mit voller Geschwindigkeit zu crawlen. Planen Sie schwerere Aufträge außerhalb der Stoßzeiten, um die Last auf Amazons Servern zu verringern.
• Auf Rotation setzen. Ein Pool von Residential-IPs verteilt Anfragen auf viele Adressen echter Nutzer, sodass keine einzelne einen Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist dies der Teil, den Sie richtig machen müssen.
• Nur das Nötige behalten. Speichern Sie die Ranking-Felder, die Ihr Projekt benötigt, und verwerfen Sie den Rest. Überprüfen Sie Ihre Selectors regelmäßig, damit der Scraper mit Markup-Änderungen Schritt hält.

Für das breitere Vorgehen zur Block-Vermeidung lesen Sie wie man Websites scrapt, ohne blockiert zu werden, und um zu verstehen, warum Rendering hier wichtig ist, wie man JavaScript-Websites crawlt. Wenn Sie die BeautifulSoup-Seite vertiefen möchten, deckt die Anleitung zur Verwendung von BeautifulSoup in Python die Parsing-Bibliothek im Detail ab.

Ist das Scrapen von Amazon legal?

Ob das Scrapen von Amazon erlaubt ist, hängt von Amazons Nutzungsbedingungen, Ihrer Rechtsordnung und dem ab, was Sie mit den Daten machen. Amazons Bedingungen schränken den automatisierten Zugriff ein, sodass Scraping unabhängig von der Sorgfalt Ihrer Werkzeuge gegen diese Bedingungen verstoßen kann. Keiner der hier aufgeführten Codes ändert daran etwas; er macht nur den technischen Teil möglich. Lesen Sie Amazons Nutzungsbedingungen und seine robots.txt und behandeln Sie beides als Grenze dessen, was Sie sammeln dürfen. Bei kommerzieller oder wettbewerblicher Nutzung ist die rechtliche Lage komplexer, und die Beratung durch einen Rechtsexperten für Ihren spezifischen Fall ist sinnvoll.

Ein paar Grundsätze, an denen es sich lohnt festzuhalten. Sammeln Sie nur öffentliche Daten: die Ränge, Produkttitel, Preise, Bewertungen und Angebots-Links, die jeder auf einer Bestseller-Seite ohne Konto sehen kann. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Amazons Server nicht belasten, und vermeiden Sie personenbezogene Daten, einschließlich allem, was mit identifizierbaren Käufern, Rezensenten oder Verkäufern über das öffentlich Gelistete hinaus verknüpft ist. Wenn Sie die Daten kommerziell weiterverwenden möchten, holen Sie sich eine Erlaubnis oder eine offizielle Vereinbarung, anstatt Schweigen als Zustimmung zu werten.

Diese Anleitung beschränkt sich bewusst auf öffentliche Bestseller-Ranking-Seiten, da das die Linie ist, die die Arbeit vertretbar macht. Sie deckt nichts hinter einem Login ab, keine Konto- oder Bestelldaten, keine persönlichen Informationen oder Versuche, Authentifizierung oder ein CAPTCHA zu umgehen, zu dem Sie nicht berechtigt sind. Für lizenzierte oder Massenzugriff bietet Amazon die Product Advertising API und andere offizielle Programme an, und das ist das richtige Werkzeug, wenn Sie große Mengen, garantierte Struktur oder kommerzielle Rechte benötigen. Wenn Ihr Projekt mehr als öffentliche Ranking-Daten benötigt, ist eine offizielle API oder eine Datenvereinbarung der richtige Weg, kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Bestseller von Amazon zurück?

Zwei Gründe. Amazon befüllt einen Großteil des Ranking-Grids clientseitig, wenn die Seite lädt und gescrollt wird, sodass eine rohe Anfrage oft eine Hülle ohne die niedriger gerandkten Artikel liefert. Dazu kommt, dass Amazon Datenverkehr, der nicht wie ein echter Browser aussieht, herausfordert oder blockiert. Das Rendern der Seite über die Crawling API hinter einer vertrauenswürdigen IP löst beides, weshalb der Scraper hier seine Anfrage darüber leitet.

Wie scrapt man Bestseller für eine bestimmte Kategorie?

Jede Bestsellerliste hat ihre eigene stabile /zgbs/-URL, zum Beispiel /Best-Sellers-Computers-Accessories/zgbs/pc für Computer und Zubehör oder /Best-Sellers-Electronics/zgbs/electronics für Elektronik. Richten Sie den Scraper auf die gewünschte Kategorie-URL. Um viele Kategorien abzudecken, halten Sie eine Zuordnung von Namen zu URLs bereit und durchlaufen Sie diese, dosieren Sie die Anfragen mit einer kurzen Verzögerung.

Kann man Bestseller für jede Produktkategorie scrapen?

Sie können die meisten Kategorien scrapen, da Amazon Bestseller für fast jede Abteilung und viele Unterkategorien veröffentlicht, jede mit ihrer eigenen Liste. Das Seitenlayout ist kategorieübergreifend konsistent, sodass dieselben Selectors in der Regel übertragbar sind. Halten Sie das Volumen vernünftig und respektieren Sie Amazons Bedingungen und Anfragerate-Erwartungen, wenn Sie auf viele Kategorien ausweiten.

Was ist der Unterschied zwischen dem BeautifulSoup-Parser und dem integrierten Scraper?

Der BeautifulSoup-Parser gibt Ihnen volle Kontrolle darüber, welche Felder Sie extrahieren und wie, auf Kosten der Pflege von Selectors, wenn sich Amazons Markup ändert. Der integrierte amazon-best-sellers-Scraper gibt die Rangliste direkt als strukturiertes JSON zurück, einschließlich ASIN, Bild und Position, ohne Selectors zu pflegen. Verwenden Sie den integrierten Scraper für Geschwindigkeit und den handgeschriebenen Parser, wenn Sie ein Feld benötigen, das er nicht zurückgibt.

Wie kann man Bestseller-Trends im Laufe der Zeit verfolgen?

Führen Sie den Scraper nach einem Zeitplan aus, stempeln Sie jeden Export mit dem Datum und speichern Sie die Snapshots. Der Vergleich aufeinanderfolgender Läufe zeigt, welche Produkte im Ranking gestiegen oder gefallen sind und wie sich die Preise verschoben haben. Diese Zeitreihe verwandelt eine einmalige Liste in Trenddaten, die Sie für Produktrecherche, Preisgestaltung und Wettbewerbsanalyse nutzen können.

Wie vermeidet man es, beim Scrapen von Amazon blockiert zu werden?

Halten Sie Ihre Pro-IP-Anfragerate niedrig, fügen Sie eine Verzögerung zwischen Seiten und Kategorien ein und leiten Sie durch rotierende Residential-IPs, damit keine einzelne Adresse einen Rate-Limit auslöst. Die Crawling API verwaltet Rotation, einen vertrauenswürdigen IP-Pool und CAPTCHA-Handling für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Statuscodes und ziehen Sie sich zurück, wenn Sie beginnen, Herausforderungen zu sehen.

HI

Hamza Ikhlaq

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zum Scraping von Zielseiten, zu Proxys und zur Crawling API schreibt.