So scrapen Sie Amazon-PPC-AnzeigendatenSponsored Products und Platzierungen

Suchen Sie auf Amazon nach einem beliebten Keyword, sind die ersten Treffer selten die organischsten. Es sind Sponsored Products: Pay-per-Click-Anzeigen (PPC), auf die Marken bieten, um an die Spitze einer Ergebnisseite zu gelangen, jeweils mit einem kleinen Label "Sponsored" oder "Ad" versehen. Diese Platzierungen sind öffentlich, und das Muster, welche Produkte auf welchen Keywords werben, ist ein direktes Fenster in die Strategie der Wettbewerber, in deren Prioritäten beim Werbebudget und in die Begriffe, um die eine Kategorie kämpft.

Diese Anleitung zeigt Ihnen, wie Sie Amazon-PPC-Anzeigendaten mit Python scrapen. Sie bauen einen kleinen, lauffähigen Scraper, der eine gerenderte Amazon-Suchergebnisseite über die Crawling API abruft, mit BeautifulSoup nur die gesponserten Platzierungen aus dem Raster herausparst und für jede Anzeige einen sauberen Datensatz zieht: Titel, Preis, Position auf der Seite und Produktlink. Die gesamte Durchsicht bleibt auf öffentliche Suchseitendaten beschränkt, die jeder Käufer sieht, und der Abschnitt zur Rechtslage am Ende ist kein Standardtext, lesen Sie ihn also, bevor Sie das auf echtes Volumen ansetzen.

Was Sie bauen werden

Ein Python-Skript, das ein Such-Keyword entgegennimmt, die gerenderte Amazon-Ergebnisseite über die Crawling API abruft, die gesponserten Karten von den organischen trennt und pro Anzeige einen strukturierten Datensatz extrahiert. Als durchgehendes Beispiel verwenden wir eine Suche nach headphones und ziehen diese Felder aus jeder gesponserten Karte:

• Titel der Titeltext des beworbenen Produkts.
• Preis der auf der gesponserten Karte angezeigte Preis.
• Position wo die Anzeige in der Ergebnisreihenfolge sitzt, sodass Sie Platzierungen oben auf der Seite gegenüber tieferen erkennen.
• Link die URL zur eigenen Detailseite des beworbenen Produkts.
• Keyword der Suchbegriff, für den die Anzeige erschien, mitgeführt, damit Sie Ergebnisse nach Abfrage gruppieren können.

Warum eine einfache Anfrage bei Amazon scheitert

Wenn Sie eine Amazon-Such-URL mit einem nackten HTTP-Client anfragen, erhalten Sie eine Antwort mit Status 200 und fast keine der Produktdaten im Body. Zwei Dinge arbeiten gegen Sie. Erstens lädt Amazon sein Suchraster dynamisch: Das anfängliche HTML ist weitgehend eine Hülle, und der wichtige Inhalt füllt sich über JavaScript und Ajax, sobald die Seite in einem Browser läuft. Speichern Sie einen rohen Abruf in eine Datei, und Sie werden feststellen, dass die gesponserten Karten schlicht nicht vorhanden sind. Zweitens markiert Amazon automatisierten Traffic schnell. Rechenzentrums-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden mit einem CAPTCHA herausgefordert oder blockiert, bevor sie die gerenderten Listings erreichen.

Ein funktionierender Amazon-Anzeigen-Scraper braucht also zwei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Käufer liest. Das können Sie selbst aus einem Headless-Browser plus einem Pool rotierender Residential-Proxys zusammenbauen, aber diese zusammenzufügen und gesund zu halten ist der Großteil der Arbeit. Die Crawling API fasst beides in einen einzigen Aufruf: Sie senden ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP und gibt Ihnen fertiges HTML zum Parsen zurück. Mehr dazu, warum clientseitig gerenderte Seiten einfachen Anfragen widerstehen, finden Sie unter wie man JavaScript-Websites crawlt.

Voraussetzungen

Bevor Sie Code schreiben, müssen ein paar Dinge bereitstehen. Keines davon dauert lange.

Grundkenntnisse in Python. Sie sollten ein Python-Skript bequem schreiben und ausführen sowie Pakete mit pip installieren können. Wenn Sie neu in der Sprache sind, bringen Sie die offizielle Python-Dokumentation und jeder Einsteigerkurs auf das Niveau, das dieses Tutorial voraussetzt.

Python 3.8 oder neuer. Bestätigen Sie Ihre Version mit python --version. Falls Sie es nicht haben, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und ein JS-Token. Registrieren Sie ein kostenloses Konto, öffnen Sie Ihr Dashboard und kopieren Sie Ihren JavaScript-Token (JS) von der Konto-Docs-Seite. Der kostenlose Tarif umfasst bis zu 20.000 Anfragen ohne Karte, was reichlich ist, um dieser Anleitung zu folgen. Behandeln Sie den Token wie ein Passwort: Er authentifiziert Ihre Anfragen, halten Sie ihn also aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit die Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die Bibliotheken, die der Scraper braucht.

python --version

python -m venv amazon_env
source amazon_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Unter Windows aktivieren Sie die Umgebung mit amazon_env\Scripts\activate statt der source-Zeile. Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, beautifulsoup4 parst das zurückgegebene HTML, sodass Sie jedes Feld per CSS-Selektor herausziehen können, und pandas hilft Ihnen, die gescrapten Anzeigen für die Keyword-Analyse am Ende zu organisieren.

Amazon-Sponsored-Platzierungen verstehen

Eine Amazon-Suchergebnisseite ist ein Raster aus Produktkarten. Die meisten sind organische Listings, nach Relevanz sortiert, aber dazwischen verstreut sind Sponsored Products: die PPC-Anzeigen. Optisch sehen sie aus wie jede andere Karte, mit einem Titel, einem Preis, einem Bild und einem Label "Sponsored". Strukturell umschließt Amazon gesponserte Karten so, dass Sie sie von den organischen unterscheiden können, und genau das erlaubt Ihnen, nur die Anzeigen zu scrapen.

Bevor Sie Selektoren schreiben, öffnen Sie eine Suchseite in Ihrem Browser, klicken Sie mit der rechten Maustaste auf eine gesponserte Karte und wählen Sie Untersuchen. Gesponserte Karten leben in Containern, die neben den üblichen data-asin-Ergebnisattributen eine AdHolder-Klasse tragen. Der Titel sitzt in einem Anker innerhalb der Überschrift der Karte, und der Preis wird über Amazons a-price-Markup offengelegt. Das sind die Haken, die Sie anvisieren. Amazons Klassennamen verschieben sich mit der Zeit, aber der AdHolder-Marker und die a-price-Struktur sind beständig geblieben, stützen Sie sich also darauf.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertige Seite zu holen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem JS-Token, bauen Sie die Such-URL aus einem Keyword und fordern Sie sie mit den Wartesoptionen an, die Amazons dynamisches Raster braucht. Den Statuscode vor dem Parsen zu prüfen hält Fehler laut statt still.

from crawlbase import CrawlingAPI

# Amazon is JavaScript-rendered, so use your JS token here
api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"page_wait": 2000, "ajax_wait": "true"}
    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__":
    keyword = "headphones"
    search_url = f"https://www.amazon.com/s?k={keyword}"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Die beiden Wartesoptionen sind für ein dynamisches Ziel wie dieses entscheidend. ajax_wait weist die API an, auf das Fertigladen asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden, sodass das spät rendernde Raster erscheint, bevor die Seite erfasst wird. Zwei Sekunden sind ein vernünftiger Anfang; erhöhen Sie es, wenn Karten fehlen. Der Body wird als latin1 dekodiert, weil Amazon-Seiten Zeichen einmischen, an denen strikte UTF-8-Dekodierung scheitern kann, und latin1 verarbeitet sie ohne Fehler. Führen Sie das Skript aus, und Sie sollten echtes Produkt-Markup sehen, nicht die leere Hülle, die ein einfacher Abruf zurückgibt. Das bestätigt, dass das Rendering funktioniert, bevor Sie auch nur einen einzigen Selektor schreiben.

Schritt 2: Die gesponserten Karten mit BeautifulSoup parsen

Mit gerendertem HTML in der Hand laden Sie es in BeautifulSoup und wählen nur die gesponserten Karten aus. Das ist der entscheidende Unterschied zu einem einfachen Such-Scrape: Statt jedes Ergebnis zu greifen, visieren Sie die AdHolder-Container an, sodass Sie Anzeigen sammeln und sonst nichts. Ziehen Sie dann jedes Feld über seinen Selektor, direkt aus dem Markup der Live-Seite portiert. Umschließen Sie jede Karte mit einem try/except, damit ein fehlerhaftes Listing den Lauf nicht zum Absturz bringt.

from bs4 import BeautifulSoup

def parse_ads(html, keyword):
    soup = BeautifulSoup(html, "html.parser")

    # Select only sponsored (PPC) cards, not organic results
    ads = soup.select(
        '.AdHolder div[data-asin], '
        'div[data-asin][data-component-type="s-search-result"].AdHolder'
    )

    results = []
    for position, ad in enumerate(ads, start=1):
        try:
            # Price inside the ad card
            price_el = ad.select_one("span.a-price span.a-offscreen")
            price = price_el.text.strip() if price_el else "Price not found"

            # Title inside the ad card
            title_el = ad.select_one(
                "div.a-section h2 a.a-link-normal span, "
                "div.a-section a.a-link-normal span.a-offscreen"
            )
            title = title_el.text.strip() if title_el else "Title not found"

            # Link to the advertised product page
            link_el = ad.select_one("h2 a.a-link-normal, a.a-link-normal")
            link = None
            if link_el and link_el.get("href"):
                link = "https://www.amazon.com" + link_el["href"]

            results.append({
                "keyword": keyword,
                "position": position,
                "title": title,
                "price": price,
                "link": link,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

Der Selektor, der die Anzeigen isoliert, ist das Herz dieses Scrapers. .AdHolder div[data-asin] trifft die gesponserten Karten, während organische Ergebnisse unberührt bleiben, sodass parse_ads immer nur PPC-Platzierungen sieht. Der Preis kommt aus dem versteckten span.a-offscreen innerhalb von Amazons a-price-Block, der den sauberen numerischen Wert enthält, und der Titel wird aus dem Überschriften-Anker der Karte gelesen, mit einem Fallback-Selektor für Layouts, die ihn anders offenlegen. enumerate(..., start=1) erfasst die Position jeder Anzeige in der Ergebnisreihenfolge, und das verwandelt eine flache Liste in Platzierungsintelligenz: Position 1 ist ein Gebot oben auf der Seite, niedrigere Zahlen sind teurere Lagen. Jedes fehlende Feld fällt auf eine Sentinel-Zeichenkette oder None zurück, statt die Schleife zum Absturz zu bringen. Wenn Sie eine Auffrischung zur Selektor-Syntax selbst möchten, behandelt die Anleitung wie man BeautifulSoup in Python verwendet sie ausführlich.

Schritt 3: Alles zusammenfügen und das Keyword analysieren

Verdrahten Sie nun den Abruf und das Parsen zu einem lauffähigen Skript und fügen Sie dann den Lohn hinzu: eine kleine Analyse, die die rohe Anzeigenliste in Wettbewerbsintelligenz verwandelt. Rufen Sie die gerenderte Suchseite ab, isolieren Sie die gesponserten Karten und laden Sie die Datensätze in einen pandas DataFrame, sodass Sie sehen, welche Produkte auf dem Keyword werben und zu welchen Preispunkten.

import json
import pandas as pd
from bs4 import BeautifulSoup
from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"page_wait": 2000, "ajax_wait": "true"}
    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 parse_ads(html, keyword):
    soup = BeautifulSoup(html, "html.parser")
    ads = soup.select(
        '.AdHolder div[data-asin], '
        'div[data-asin][data-component-type="s-search-result"].AdHolder'
    )
    results = []
    for position, ad in enumerate(ads, start=1):
        try:
            price_el = ad.select_one("span.a-price span.a-offscreen")
            price = price_el.text.strip() if price_el else "Price not found"
            title_el = ad.select_one(
                "div.a-section h2 a.a-link-normal span, "
                "div.a-section a.a-link-normal span.a-offscreen"
            )
            title = title_el.text.strip() if title_el else "Title not found"
            link_el = ad.select_one("h2 a.a-link-normal, a.a-link-normal")
            link = None
            if link_el and link_el.get("href"):
                link = "https://www.amazon.com" + link_el["href"]
            results.append({
                "keyword": keyword,
                "position": position,
                "title": title,
                "price": price,
                "link": link,
            })
        except Exception as e:
            print(f"Skipped a card: {e}")
    return results

def analyze(ads):
    if not ads:
        print("No sponsored ads found for this keyword.")
        return
    df = pd.DataFrame(ads)
    print(f"Sponsored placements found: {len(df)}")
    print("\nTop-of-page advertisers:")
    print(df[["position", "title", "price"]].head())
    return df

def main():
    keyword = "headphones"
    search_url = f"https://www.amazon.com/s?k={keyword}"
    html = crawl(search_url)
    if not html:
        return
    ads = parse_ads(html, keyword)
    print(json.dumps(ads, indent=2))
    df = analyze(ads)
    if df is not None:
        df.to_csv("amazon_ppc_ads.csv", index=False)

if __name__ == "__main__":
    main()

Der analyze-Schritt ist es, der daraus ein Werkzeug für Anzeigenintelligenz macht statt eines rohen Dumps. Die Datensätze in einen DataFrame zu laden lässt Sie nach Position sortieren, um zu sehen, wer die Spitzengebote gewinnt, nach Preis gruppieren, um das wettbewerbliche Preisband abzulesen, und alles in amazon_ppc_ads.csv schreiben, um es über die Zeit zu verfolgen. Lassen Sie dasselbe Keyword nach Zeitplan laufen, und die Differenzen sagen Ihnen, wann ein neuer Wettbewerber in die Auktion eintritt oder ein bestehender seine Gebotspriorität ändert. Wenn Sie diese Preise in ein breiteres Modell einspeisen möchten, zeigt die Anleitung Web Scraping für Preisintelligenz nutzen, wohin diese Art von Daten als Nächstes geht.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus, und Sie erhalten eine saubere Liste gesponserter Datensätze, einen pro Anzeige, plus die CSV und eine kurze Zusammenfassung. Die JSON-Form sieht so aus:

[
  {
    "keyword": "headphones",
    "position": 1,
    "title": "Wireless Bluetooth Headphones, Over-Ear, 40H Playtime",
    "price": "$39.99",
    "link": "https://www.amazon.com/dp/..."
  },
  {
    "keyword": "headphones",
    "position": 2,
    "title": "Noise Cancelling Headphones, Wired and Wireless",
    "price": "$59.95",
    "link": "https://www.amazon.com/dp/..."
  }
]

Jeder Datensatz trägt das Keyword, die Position auf der Seite, den beworbenen Titel und Preis sowie einen Link in die Produktseite. Das reicht, um die zentrale Frage der Wettbewerbsintelligenz zu beantworten: Für jeden Begriff, der Sie interessiert, welche Produkte zahlen, um an der Spitze zu sitzen, und in welchem Preisband konkurrieren sie.

Über Keywords und Seiten hinweg skalieren

Ein Keyword auf einer Seite ist eine Demo. Der echte Wert entsteht, wenn Sie eine Liste von Keywords nach Zeitplan laufen lassen und verfolgen, wie sich das Set der Werbetreibenden verschiebt. Schleifen Sie Ihre Zielbegriffe durch, scrapen Sie für jeden die gesponserten Karten und verketten Sie die Ergebnisse, sodass eine einzige CSV das vollständige Wettbewerbsbild enthält.

import time

def scrape_keywords(keywords):
    all_ads = []
    for keyword in keywords:
        url = f"https://www.amazon.com/s?k={keyword}"
        html = crawl(url)
        if not html:
            continue
        ads = parse_ads(html, keyword)
        all_ads.extend(ads)
        print(f"{keyword}: {len(ads)} sponsored placements")
        time.sleep(2)
    return all_ads

keywords = ["headphones", "wireless earbuds", "bluetooth speaker"]
ads = scrape_keywords(keywords)

Das time.sleep(2) zwischen Keywords taktet den Lauf, sodass Sie die Suche nicht in einer engen Schleife bombardieren, was der schnellste Weg ist, gedrosselt zu werden. Um für ein einzelnes Keyword weitere Ergebnisseiten abzulaufen, paginiert Amazon die Suche mit einem &page=-Parameter an der URL, sodass Sie ihn auf dieselbe Weise erhöhen und stoppen, wenn eine Seite keine gesponserten Karten zurückgibt. Halten Sie die Obergrenze bescheiden: Die wertvollsten Anzeigenplatzierungen sitzen ohnehin auf den ersten ein oder zwei Seiten.

Unblockiert bleiben

Selbst mit erledigtem Rendering achtet Amazon auf Scraper-förmigen Traffic. Ein paar Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes harte kommerzielle Ziel.

• Takten Sie Ihre Anfragen. Verteilen Sie Anfragen mit einer Verzögerung zwischen Keywords und Seiten, statt mit voller Geschwindigkeit zu crawlen. Das time.sleep in der Schleife ist die Untergrenze, nicht die Obergrenze.
• Stützen Sie sich auf Rotation. Ein Pool von Residential-IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne ein Ratenlimit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack rollen, ist das der Teil, den Sie richtig hinbekommen müssen.
• Lesen Sie die Statuscodes. Ein Lauf, der anfängt, Challenges oder Fehler zurückzugeben, sagt Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr genügt. Behandeln Sie das als Signal zum Zurückfahren, nicht als Rauschen, das man ignoriert.

Für das umfassendere Drehbuch, einen Scraper gegen verteidigte Seiten gesund zu halten, siehe wie man Websites scrapt, ohne blockiert zu werden.

Ist es legal, Amazon-Anzeigendaten zu scrapen?

Ob das Scrapen von Amazon erlaubt ist, hängt von Amazons Nutzungsbedingungen, Ihrer Gerichtsbarkeit und davon ab, was Sie mit den Daten tun. Amazons Bedingungen schränken automatisierten Zugriff ein, daher kann Scraping gegen diese Bedingungen verstoßen, egal wie sorgfältig Ihr Werkzeug ist. Nichts vom Code hier ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie Amazons Nutzungsbedingungen und seine robots.txt und behandeln Sie beide als Grenze für das, was Sie sammeln.

Ein paar Leitlinien, an denen es sich festzuhalten lohnt. Der gesponserte Titel, Preis, die Position und der Produktlink, die dieser Scraper zieht, sind öffentliche Daten: Jeder, der dieselbe Suche ausführt, sieht dieselben Anzeigen, ohne dass ein Konto erforderlich ist. Bleiben Sie auf dieser öffentlichen, der Anzeige zugewandten Oberfläche. Respektieren Sie Amazons angegebene Ratenerwartungen und halten Sie Ihr Anfragevolumen niedrig genug, dass Sie seine Server nicht belasten. Vermeiden Sie personenbezogene Daten, einschließlich alles, was an identifizierbare Käufer, Rezensenten oder Verkäufer gebunden ist, über das hinaus, was auf einer Ergebnisseite öffentlich gelistet ist, und verteilen Sie keine urheberrechtlich geschützten Produktbilder oder Beschreibungen pauschal weiter. Anzeigendaten für Ihre eigene Wettbewerbsanalyse zu nutzen ist etwas ganz anderes, als Amazons Inhalte erneut zu veröffentlichen.

Diese Anleitung ist bewusst auf öffentliche gesponserte Platzierungen auf Suchseiten beschränkt, weil das die Linie ist, die die Arbeit vertretbar hält. Sie behandelt nichts hinter einem Login, keine Seller-Central- oder Kampagnenverwaltungsdaten, keine privaten Kontometriken eines anderen Werbetreibenden, keine Zahlungsabläufe und keinen Versuch, eine Authentifizierung zu umgehen. Die auf der Seite sichtbaren "Sponsored"-Daten, die Sie hier sammeln, sind der öffentliche Anzeigen-Fußabdruck des Wettbewerbers, nicht seine internen Kampagnenzahlen. Für lizenzierten oder massenhaften Zugriff bietet Amazon offizielle Werbe- und Produkt-APIs, und das ist das richtige Werkzeug, wenn Sie große Volumen, garantierte Struktur oder kommerzielle Rechte brauchen. Wenn Ihr Projekt mehr als öffentliche Anzeigenplatzierungen braucht, ist eine offizielle API oder eine Datenvereinbarung der richtige Weg, nicht ein cleverer Scraper.

Häufig gestellte Fragen

Was ist Amazon-PPC-Werbung?

Amazon-PPC-Werbung (Pay-per-Click) lässt Verkäufer und Marken Produkte innerhalb von Amazons Suchergebnissen und Produktseiten bewerben. Diese Sponsored Products sind mit "Sponsored" oder "Ad" gekennzeichnet, und der Werbetreibende zahlt nur, wenn ein Käufer klickt. Da die Anzeigen gebotsgesteuert sind, ist das Set der Produkte, die auf einem bestimmten Keyword werben, ein Live-Indikator dafür, welche Marken Geld ausgeben, um um diesen Begriff zu konkurrieren.

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

Weil Amazon sein Suchraster dynamisch mit JavaScript und Ajax lädt. Das anfängliche HTML ist weitgehend eine Hülle, sodass eine rohe HTTP-Anfrage Status 200 mit leeren gesponserten und organischen Karten zurückgibt. Um echte Daten zu erhalten, müssen Sie die Seite zuerst rendern, und genau das erledigt der JS-Token der Crawling API für Sie, bevor BeautifulSoup sie parst.

Wie scrape ich nur die gesponserten Anzeigen und nicht die organischen Ergebnisse?

Amazon umschließt gesponserte Karten in Containern, die eine AdHolder-Klasse tragen. Eine Auswahl auf .AdHolder div[data-asin] trifft nur diese Karten, sodass Ihr Parser PPC-Platzierungen sammelt und organische Listings vollständig überspringt. Aus jeder Anzeigenkarte lesen Sie dann den Titel aus ihrem Überschriften-Anker, den Preis aus dem a-price-Block und den href für den Produktlink.

Mein Titel oder Preis kommt als "not found" zurück. Was hat sich geändert?

Mit ziemlicher Sicherheit Amazons Markup. Seine Klassennamen und Kartenstruktur ändern sich ohne Vorankündigung, und die a-price- oder Überschriften-Anker-Selektoren oben können aufhören zu treffen. Untersuchen Sie eine Live-Sponsored-Karte erneut in den Entwicklertools Ihres Browsers, bestätigen Sie den AdHolder-Wrapper sowie die inneren Preis- und Titel-Selektoren und aktualisieren Sie sie. Regelmäßige Selektorpflege ist für jeden produktiven Scraper normal.

Was kann ich mit gescrapten Amazon-Anzeigendaten machen?

Verfolgen Sie die Werbung der Wettbewerber im Zeitverlauf: welche Produkte das gesponserte Set für ein Keyword betreten oder verlassen, wo sie platzieren und in welchem Preisband sie konkurrieren. Lassen Sie dieselben Keywords nach Zeitplan laufen, und die Differenzen bringen neue Einsteiger und Verschiebungen der Gebotsprioritäten ans Licht. Die Felder Position und Preis fließen direkt in Dashboards für Anzeigen- und Preisintelligenz ein.

Brauche ich für Amazon den normalen Token oder den JS-Token?

Den JS-Token. Der normale Token holt statisches HTML, das auf Amazon dieselbe leere Hülle ist, die ein einfacher Abruf zurückgibt. Der JS-Token rendert die Seite in einem echten Browser, bevor er das HTML zurückreicht, sodass die gesponserten Karten vorhanden sind, wenn Ihr Parser läuft. Kombinieren Sie ihn mit den Optionen page_wait und ajax_wait, damit das dynamische Raster Zeit hat, fertig zu laden.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.