So automatisieren Sie Amazon-Scrapinggeplantes, hands-off Produktdaten-Scraping

Amazon ist eine der reichhaltigsten Quellen öffentlicher Handelsdaten im Web: Produkttitel, Preise, Bewertungen, Verfügbarkeit und Bestseller-Rankings, die sich im Laufe des Tages verschieben. Diese Daten einmal abzurufen ist nützlich, aber der eigentliche Wert zeigt sich, wenn Sie sie nach einem Zeitplan sammeln, sodass Sie verfolgen können, wie sich ein Preis bewegt, wann ein Listing nicht mehr vorrätig ist oder wie ein Ranking über eine Woche klettert. Ein einzelner manueller Lauf kann Ihnen das alles nicht verraten.

Diese Anleitung zeigt Ihnen, wie Sie Amazon-Scraping mit JavaScript und Node.js automatisieren. Sie bauen einen Scraper, der öffentliche Produkt- und Suchdaten über die Crawling API abruft, und kapseln ihn dann in die Teile, die ihn hands-off machen: einen geplanten Job, der ihn per Cron ausführt, den asynchronen Crawler mit Webhook-Callback für große Läufe, dauerhaften Speicher für die Ergebnisse und Fehlerbehandlung, damit eine einzelne fehlgeschlagene Anfrage den Batch nicht zerstört. Die gesamte Anleitung beschränkt sich auf öffentliche Produktdaten, und der Abschnitt zur Rechtslage am Ende ist kein Standardtext, also lesen Sie ihn, bevor Sie das auf echte Mengen anwenden. Wenn Sie nur einen einmaligen Abruf brauchen, behandeln unsere Leitfäden zum Scrapen von Amazon-Produktdaten und zum Scrapen von Amazon-Bestsellern den Einzellauf; dieser Post handelt davon, sie eigenständig laufen zu lassen.

Was Sie bauen werden

Eine Node.js-Automatisierung, die öffentliche Amazon-Produkt- und Suchseiten nach einem Zeitplan scraped und einen strukturierten Datensatz pro Lauf speichert. Wir verwenden eine Suchergebnisseite als durchgängiges Beispiel und ziehen diese Felder pro Artikel:

• ASIN die Amazon Standard Identification Number, die ein Produkt eindeutig identifiziert.
• Titel der Produktname, wie er auf der Karte angezeigt wird.
• Preis der angezeigte Preis, wie "$29.99".
• Bewertung die durchschnittliche Sternebewertung, wenn vorhanden.
• Rezensionen die auf der Karte angezeigte Rezensionsanzahl.
• Produkt-URL der Link zur individuellen Produktseite.

Um diesen Scraper herum fügen Sie vier Automatisierungsteile hinzu: einen Cron-gesteuerten Scheduler, einen asynchronen Lauf mit Webhook-Callback für große Jobs, einen nach Laufzeitstempel verschlüsselten JSON-Speicher und einen Retry-Wrapper, der vorübergehende Fehler behandelt, ohne den gesamten Batch abzubrechen.

Warum eine einfache Anfrage bei Amazon scheitert

Wenn Sie eine Amazon-Such-URL mit einem einfachen HTTP-Client anfragen, erhalten Sie selten die Daten, nach denen Sie suchen. Amazon rendert einen Großteil der Seite im Browser und fordert automatisierten Traffic aggressiv heraus. Eine Datacenter-IP, die Produktseiten in einem engen Loop anfragt, bekommt ein CAPTCHA, einen "Robot Check"-Zwischenbildschirm oder eine vollständige Blockierung, lange bevor Sie eine nützliche Probe sammeln. Selbst wenn eine Anfrage erfolgreich ist, kann das zurückgegebene Markup ein abgespecktes Gerüst sein, dem Preise und Bewertungen fehlen.

Ein funktionierender Amazon-Scraper braucht also zwei Dinge in einer einzigen Anfrage: eine Seite, die tatsächlich rendert, und eine IP, die die Plattform als echten Besucher einordnet. Sie können das selbst mit einem Headless-Browser plus einem Pool rotierender Wohnproxies zusammenbauen, aber das Zusammenfügen und Instandhalten ist der Großteil der Arbeit, und es wird schlimmer, wenn Sie nach einem Zeitplan laufen und die Fehler unbeaufsichtigt anhäufen. Die Crawling API bündelt beides in einem einzigen Aufruf: Sie senden ihr die URL, sie ruft die Seite hinter einer vertrauenswürdigen, rotierenden IP ab, und sie gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Sie brauchen ein paar Dinge, bevor Sie Code schreiben. Keines davon dauert lange.

JavaScript- und Node.js-Grundkenntnisse. Sie sollten in der Lage sein, ein Node-Skript zu schreiben und auszuführen sowie Pakete mit npm zu installieren. Wenn Sie neu in Node sind, erklärt unser Leitfaden zum Aufbauen eines Web-Scrapers mit Node.js die Grundlagen, die dieses Tutorial voraussetzt.

Node.js 16 oder höher. Bestätigen Sie Ihre Version mit node --version. Falls Sie es nicht haben, installieren Sie es von der Node.js-Website oder über einen Versionsmanager wie nvm.

Ein Crawlbase-Konto und Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token. Das kostenlose Kontingent umfasst bis zu 20.000 Anfragen ohne Kreditkarte, was ausreicht, um das zu erstellen und zu planen. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es also aus der Versionskontrolle heraus und lesen Sie es aus einer Umgebungsvariable.

Projekt einrichten

Erstellen Sie einen Projektordner, initialisieren Sie ihn und installieren Sie die Bibliotheken, die die Automatisierung benötigt.

node --version

mkdir amazon-automation && cd amazon-automation
npm init -y

npm install crawlbase cheerio node-cron

Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Node-Client für die Crawling API und den asynchronen Crawler, cheerio parst das zurückgegebene HTML mit einer jQuery-artigen API, damit Sie Felder per CSS-Selektor herausziehen können, und node-cron führt den Scraper nach einem Zeitplan aus dem gleichen Prozess heraus aus. Exportieren Sie Ihr Token einmal, damit jedes Skript im Ordner es lesen kann:

export CRAWLBASE_TOKEN='YOUR_CRAWLBASE_TOKEN'

Schritt 1: Die Suchseite abrufen und parsen

Beginnen Sie mit dem Scraper selbst, da alles andere diesen Kern automatisiert. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token, fordern Sie die Such-URL an und parsen Sie jede Ergebniskarte mit cheerio. Das Prüfen des Statuscodes vor dem Parsen hält Fehler sichtbar statt lautlos.

const { CrawlingAPI } = require('crawlbase');
const cheerio = require('cheerio');

const api = new CrawlingAPI({ token: process.env.CRAWLBASE_TOKEN });

async function scrapeSearch(searchUrl) {
  const response = await api.get(searchUrl);
  if (response.statusCode !== 200) {
    throw new Error(`Request failed: ${response.statusCode}`);
  }
  return parseSearch(response.body);
}

function parseSearch(html) {
  const $ = cheerio.load(html);
  const items = [];

  $('div[data-asin]').each((_, el) => {
    const card = $(el);
    const asin = card.attr('data-asin');
    const title = card.find('h2 span').text().trim();
    if (!asin || !title) return;

    items.push({
      asin,
      title,
      price: card.find('.a-price .a-offscreen').first().text().trim() || null,
      rating: card.find('.a-icon-alt').first().text().trim() || null,
      reviews: card.find('.a-size-base.s-underline-text').first().text().trim() || null,
      productUrl: `https://www.amazon.com/dp/${asin}`,
    });
  });

  return items;
}

const searchUrl = 'https://www.amazon.com/s?k=wireless+headphones';
scrapeSearch(searchUrl).then((items) => {
  console.log(JSON.stringify(items.slice(0, 3), null, 2));
});

Ein paar Details machen das robust. Amazon stempelt jede Ergebniskarte mit einem data-asin-Attribut, das der stabilste Anker auf der Seite ist, also verankern wir darauf und überspringen jede Karte ohne ASIN und Titel (gesponserte Slots und Layout-Platzhalter haben oft einen, aber nicht den anderen). Der Preis befindet sich in einem verborgenen .a-offscreen-Span, der den sauberen, formatierten Wert enthält, was zuverlässiger ist als das sichtbare aufgeteilte Scrapen. Jedes Feld fällt auf null zurück, wenn es fehlt, sodass ein abwesender Wert den Lauf nie zum Absturz bringt. Speichern Sie die Datei als scraper.js und führen Sie sie mit node scraper.js aus; Sie sollten ein sauberes Array von Produktdatensätzen sehen.

Schritt 2: Jeden Lauf speichern

Automatisierung ist nur nützlich, wenn die Daten erhalten bleiben, also schreiben Sie jeden Lauf nach einem Zeitstempel verschlüsselt auf die Festplatte. Das gibt Ihnen eine Historie, die Sie später vergleichen können, um zu sehen, wie sich ein Preis oder Ranking bewegt hat. Eine flache JSON-Datei pro Lauf ist der einfachste dauerhafte Speicher und lässt sich danach einfach in alles andere laden.

const fs = require('fs');
const path = require('path');

function saveRun(items) {
  const dir = path.join(__dirname, 'data');
  fs.mkdirSync(dir, { recursive: true });

  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
  const file = path.join(dir, `run-${stamp}.json`);

  const payload = { scrapedAt: new Date().toISOString(), count: items.length, items };
  fs.writeFileSync(file, JSON.stringify(payload, null, 2));
  console.log(`Saved ${items.length} items to ${file}`);
  return file;
}

Der ISO-Zeitstempel sortiert sich natürlich, sodass das Auflisten des data-Verzeichnisses die Laufhistorie in Reihenfolge gibt. Für einen produktiven Job würden Sie das gegen eine Datenbank tauschen, aber der Vertrag ist derselbe: ein Datensatz-Set pro Lauf, gestempelt mit dem Zeitpunkt der Erfassung. Jede gespeicherte Datei trägt ein scrapedAt-Feld, damit ein späterer Vergleich genau weiß, zu welchem Moment ein Preis gehört.

Schritt 3: Wiederholungsversuche für vorübergehende Fehler hinzufügen

Ein geplanter Job läuft unbeaufsichtigt, also darf eine einzelne fehlerhafte Anfrage den Batch nicht abbrechen. Kapseln Sie den Abruf in einen kleinen Retry-Helfer, der zwischen Versuchen zurückfährt und erst nach wenigen Versuchen aufgibt. Die meisten vorübergehenden Fehler (eine momentane Blockierung, ein langsames Rendering, ein Netzwerkproblem) klären sich beim nächsten Versuch.

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

async function scrapeWithRetry(url, attempts = 3) {
  for (let i = 1; i <= attempts; i++) {
    try {
      return await scrapeSearch(url);
    } catch (err) {
      console.warn(`Attempt ${i} failed: ${err.message}`);
      if (i === attempts) throw err;
      await sleep(2000 * i);
    }
  }
}

Das Backoff multipliziert die Wartezeit mit der Versuchsnummer, sodass die Lücken wachsen (2 Sekunden, dann 4, dann 6), statt ein Ziel zu bombardieren, das bereits kämpft. Nach dem letzten Versuch wird der Fehler erneut ausgelöst, was dem Aufrufer ermöglicht zu entscheiden, ob er ihn protokolliert und mit dem nächsten Keyword weitermacht oder den Lauf stoppt. Dieses Muster ist der Unterschied zwischen einem Scheduler, der sich selbst erholt, und einem, den Sie beaufsichtigen müssen.

Schritt 4: Mit Cron planen

Jetzt machen Sie es hands-off. Das node-cron-Paket führt eine Funktion auf einem Standard-Cron-Ausdruck aus dem Prozess heraus aus, sodass Sie den Scraper, den Speicher und die Retry-Logik an einem Ort halten können. Hier führen wir den Job jeden Morgen um 6 Uhr aus und sammeln jedes Mal eine Liste von Keywords.

const cron = require('node-cron');

const keywords = ['wireless headphones', 'mechanical keyboard', 'usb c hub'];

async function runJob() {
  console.log(`Run started at ${new Date().toISOString()}`);
  const all = [];

  for (const keyword of keywords) {
    const url =
      `https://www.amazon.com/s?k=${encodeURIComponent(keyword)}`;
    try {
      const items = await scrapeWithRetry(url);
      all.push(...items.map((it) => ({ ...it, keyword })));
    } catch (err) {
      console.error(`Skipping "${keyword}": ${err.message}`);
    }
    await sleep(3000);
  }

  saveRun(all);
}

cron.schedule('0 6 * * *', runJob);
console.log('Scheduler running. Daily job at 06:00.');

Der Ausdruck 0 6 * * * bedeutet Minute 0 von Stunde 6, jeden Tag. Jedes Keyword läuft durch den Retry-Wrapper, ein fehlgeschlagenes Keyword wird protokolliert und übersprungen statt den Lauf zu beenden, und eine 3-Sekunden-Pause zwischen Keywords hält das Tempo höflich. Lassen Sie diesen Prozess laufen (unter einem Prozessmanager wie pm2 oder einem systemd-Dienst in der Produktion) und er sammelt jeden Morgen ohne weitere Eingabe einen frischen Snapshot. Wenn Sie lieber keinen Node-Prozess am Laufen halten möchten, lassen Sie die Cron-Zeile weg und lösen Sie stattdessen runJob von einem System-Crontab oder einem Cloud-Scheduled-Task aus, der node job.js auf demselben Ausdruck ausführt.

Schritt 5: Mit dem asynchronen Crawler und einem Webhook skalieren

Die synchrone Schleife oben ist für einige Keywords in Ordnung, aber sobald ein Lauf Hunderte von Produkt-URLs umfasst, wird das sequenzielle Warten auf jede Anfrage zum Engpass. Der asynchrone Crawler ist dafür gebaut: Sie schieben ihm URLs, er ruft jede im Hintergrund hinter einer vertrauenswürdigen IP ab, und er liefert die fertige Seite an einen Webhook, den Sie hosten. Ihr Scheduler hört auf, bei jedem Abruf zu blockieren, und stellt nur Arbeit in die Warteschlange, dann verarbeitet Ergebnisse, wenn sie ankommen.

Zuerst stellen Sie die URLs in die Warteschlange. Der asynchrone Client nimmt dasselbe Token und eine callback-URL, die auf Ihren Webhook-Endpunkt zeigt.

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: process.env.CRAWLBASE_TOKEN });

const productUrls = [
  'https://www.amazon.com/dp/B0CHX1W1XY',
  'https://www.amazon.com/dp/B09G9FPHY6',
];

async function enqueue() {
  for (const url of productUrls) {
    const response = await api.getAsync(url, {
      callback: 'https://your-server.com/crawlbase-webhook',
    });
    console.log(`Queued ${url} -> rid ${response.json.rid}`);
  }
}

enqueue();

Jeder Aufruf gibt sofort eine Anfrage-ID (rid) zurück, sodass die Schleife schnell endet, egal wie viele URLs Sie in die Warteschlange stellen. Crawlbase erledigt den Abruf im Hintergrund und sendet, wenn jede Seite fertig ist, das fertige HTML per POST an Ihren Callback. Ihr Webhook empfängt die Seiten, parst und speichert sie, genau wie der synchrone Pfad, aber vom Einreihen in die Warteschlange entkoppelt.

const express = require('express');
const cheerio = require('cheerio');

const app = express();
app.use(express.text({ type: '*/*', limit: '5mb' }));

app.post('/crawlbase-webhook', (req, res) => {
  const $ = cheerio.load(req.body);
  const title = $('#productTitle').text().trim();
  const price = $('.a-price .a-offscreen').first().text().trim();

  if (title) saveRun([{ title, price: price || null }]);
  res.sendStatus(200);
});

app.listen(3000, () => console.log('Webhook listening on 3000'));

Die Callback-URL muss öffentlich erreichbar sein, also exponieren Sie während der Entwicklung Ihren lokalen Server mit einem Tunnel wie ngrok und verwenden Sie diese HTTPS-Adresse als callback-Wert. Geben Sie immer schnell einen 200 zurück, damit Crawlbase weiß, dass die Seite empfangen wurde; erledigen Sie das Parsing und die Speicherung entweder vor der Antwort oder in einem Hintergrundtask. Für einen tieferen Einblick in dieses Muster lesen Sie, wie Sie Daten mit dem Crawlbase Crawler extrahieren, was die asynchrone Warteschlange und Callbacks im Detail behandelt.

Wie die Ausgabe aussieht

Jeder Lauf schreibt eine einzelne JSON-Datei unter data/, gestempelt mit dem Zeitpunkt der Erfassung. Die Form bleibt dieselbe, egal ob die Datensätze aus der synchronen Schleife oder dem asynchronen Webhook kamen, sodass alles nachgelagert ein Format liest.

{
  "scrapedAt": "2026-06-11T06:00:04.812Z",
  "count": 2,
  "items": [
    {
      "asin": "B0CHX1W1XY",
      "title": "Wireless Over-Ear Headphones, 40H Playtime",
      "price": "$59.99",
      "rating": "4.5 out of 5 stars",
      "reviews": "2,184",
      "productUrl": "https://www.amazon.com/dp/B0CHX1W1XY",
      "keyword": "wireless headphones"
    },
    {
      "asin": "B09G9FPHY6",
      "title": "Compact Mechanical Keyboard, Hot-Swappable",
      "price": "$45.99",
      "rating": "4.4 out of 5 stars",
      "reviews": "1,073",
      "productUrl": "https://www.amazon.com/dp/B09G9FPHY6",
      "keyword": "mechanical keyboard"
    }
  ]
}

Mit einer solchen Laufhistorie zahlt sich die Automatisierung aus: Laden Sie zwei beliebige Laufdateien, ordnen Sie Artikel nach ASIN zu, und Sie haben eine Preis-über-Zeit-Reihe, die Sie visualisieren oder bei der Sie Alarme setzen können. Derselbe Speicher speist einen Bestseller-Tracker oder einen Lagerbestandsänderungs-Benachrichtiger, ohne den Scraper zu ändern.

Entsperrt bleiben

Selbst mit der Crawling API, die Rendering und Rotation verwaltet, braucht ein geplanter Job, der unbeaufsichtigt läuft, Gewohnheiten, die ihn über Wochen, nicht nur einen guten Lauf, gesund halten.

• Den Zeitplan takten, nicht nur die Schleife. Jede paar Minuten rund um die Uhr zu laufen sieht gar nicht aus wie ein Mensch und verbraucht Credits schnell. Eine tägliche oder stündliche Kadenz reicht für Preis- und Ranking-Tracking aus und hält Ihren Fußabdruck klein.
• Rotation ihre Arbeit erledigen lassen. Die Crawling API verteilt Anfragen auf viele Wohn-IPs, sodass keine einzelne ein Ratenlimit auslöst. Wenn Sie stattdessen Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen, und unser Leitfaden zum Scrapen von Websites ohne Blockierung behandelt das vollständige Playbook.
• Die Statuscodes in Ihren Logs beobachten. Ein geplanter Lauf, der anfängt, Nicht-200-Antworten zurückzugeben, teilt Ihnen mit, dass sich etwas geändert hat. Weil der Job jeden Fehler protokolliert und der Retry-Wrapper zurückfährt, erhalten Sie eine Papierspur statt einer stillen Lücke in Ihren Daten.

Ist es legal, Amazon-Scraping zu automatisieren?

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 automatisierten Zugriff ein, sodass Scraping gegen diese Bedingungen verstoßen kann, egal wie sorgfältig Ihr Werkzeug ist. Keiner der hier verwendete Code ändert daran etwas; er macht lediglich den technischen Teil zum Funktionieren. Lesen Sie Amazons Nutzungsbedingungen und seine robots.txt, und behandeln Sie beides als Grenze dessen, was Sie sammeln.

Ein paar Grundsätze, an denen es sich lohnt festzuhalten. Sammeln Sie nur öffentliche Produktdaten: Titel, Preis, Bewertung, Rezensionsanzahl, ASIN und den Produkt-Link, den jeder ohne Konto sehen kann. Respektieren Sie Amazons angegebene Ratenerwartungen und halten Sie Ihr geplantes Volumen so niedrig, dass Sie seine Server nicht belasten, was genau der Grund ist, warum die Cron-Kadenz und das Taktieren in dieser Anleitung wichtig sind. Vermeiden Sie personenbezogene Daten, einschließlich allem, was mit identifizierbaren Rezensenten über den öffentlichen Rezensionstext auf einer Seite hinaus in Verbindung steht. Wenn Sie die Daten kommerziell weiterverwenden möchten, holen Sie die Erlaubnis oder eine Lizenzvereinbarung ein, anstatt zu unterstellen, dass Schweigen Zustimmung bedeutet.

Für Volumen oder kommerzielle Nutzung bietet Amazon offizielle Wege, einschließlich der Product Advertising API und der händlerseitigen Selling Partner API, und das sind die richtigen Werkzeuge, wenn Sie große Mengen, garantierte Struktur oder kommerzielle Rechte benötigen. Diese Anleitung beschränkt sich bewusst auf öffentliche Produkt- und Suchseiten, weil das die Grenze ist, die die Arbeit verteidigbar macht. Sie deckt nichts hinter einem Login ab, keine Käufer- oder Verkäuferkontodaten, keine Bestellhistorie, keine privaten Nachrichten und keinen Versuch, die Authentifizierung zu umgehen. Wenn Ihr Projekt mehr als öffentliche Daten erfordert, sind Amazons offizielle APIs oder eine Datenvereinbarung der richtige Weg, kein cleverer Scraper oder ein schnellerer Zeitplan.

Häufig gestellte Fragen

Wie plane ich einen Amazon-Scraper, der automatisch läuft?

Der einfachste Weg in Node ist node-cron, das eine Funktion auf einem Standard-Cron-Ausdruck aus Ihrem Prozess heraus ausführt. Schreiben Sie Ihre Scrape-und-Speicher-Logik als eine Funktion und planen Sie sie dann, zum Beispiel 0 6 * * * für täglich um 6 Uhr. Wenn Sie lieber keinen Node-Prozess am Laufen halten möchten, geben Sie dieselbe Logik in ein Skript und lösen Sie es von einem System-Crontab oder einem Cloud-Scheduled-Task auf demselben Ausdruck aus.

Wann sollte ich den asynchronen Crawler statt synchroner Anfragen verwenden?

Verwenden Sie den asynchronen Crawler, sobald ein Lauf viele URLs umfasst und das sequenzielle Warten auf jede Anfrage zum Engpass wird. Sie stellen URLs mit einem Webhook-Callback in die Warteschlange, Crawlbase ruft jede Seite im Hintergrund hinter einer vertrauenswürdigen IP ab und sendet das fertige HTML per POST an Ihren Endpunkt. Synchrone Anfragen sind einfacher und für eine Handvoll Seiten pro Lauf in Ordnung.

Wie behandle ich Fehler in einem unbeaufsichtigten Scraping-Job?

Kapseln Sie jeden Abruf in einen Retry-Helfer, der zwischen Versuchen zurückfährt und nach wenigen Versuchen aufgibt, dann fangen und protokollieren Sie einen Fehler auf Keyword-Ebene, sodass eine schlechte Anfrage diesen Artikel überspringt statt den Batch abzubrechen. Protokollieren Sie jeden Nicht-200-Status, damit Ihr Lauf eine Papierspur hinterlässt. Die Rotation der Crawling API verhindert bereits die meisten Blockierungen, also decken Wiederholungsversuche hauptsächlich vorübergehende Probleme ab.

Brauche ich das JS-Token, um Amazon zu scrapen?

Oft nicht. Viele Amazon-Such- und Produktseiten parsen problemlos mit dem normalen Token, das weniger Credits kostet. Beginnen Sie mit dem normalen Token und wechseln Sie zum JavaScript (JS)-Token nur, wenn ein Feld, das Sie brauchen, leer zurückkommt, weil es clientseitig gerendert wird. Das günstigere Token dort zu verwenden, wo es funktioniert, hält einen geplanten Job im kostenlosen Kontingent erschwinglich.

Wo soll ich die gescrapten Ergebnisse speichern?

Für einen kleinen Job ist eine datierte JSON-Datei pro Lauf dauerhaft und lässt sich später einfach vergleichen, um Preis- oder Rankingänderungen zu verfolgen. Wenn das Volumen wächst, wechseln Sie zu einer Datenbank, damit Sie effizient über Läufe hinweg abfragen können. Halten Sie in jedem Fall die Datensatzform stabil und stempeln Sie jeden Lauf mit einer scrapedAt-Zeit, damit ein späterer Vergleich weiß, zu welchem Moment ein Wert gehört.

Ist es legal, Amazon-Scraping zu automatisieren?

Das Automatisieren ändert die Regeln nicht; es führt dasselbe Scrape nur wiederholt aus, was die Bedeutung des Taktierens erhöht. Bleiben Sie bei öffentlichen Produktdaten, respektieren Sie Amazons Nutzungsbedingungen und robots.txt, halten Sie Ihr geplantes Volumen bescheiden und vermeiden Sie personenbezogene Daten und alles hinter einem Login. Für Volumen oder kommerzielle Wiederverwendung ist Amazons offizielle Product Advertising oder Selling Partner API der sanktionierte Weg.

TA

Thomas Adewale

Technischer Redakteur · Crawlbase

Technischer Redakteur bei Crawlbase, der über Proxy-Netzwerke, Rotationsstrategien und die technischen Grundlagen für zuverlässiges Crawling im großen Maßstab schreibt.