E-Commerce-Website-Crawling mit JavaScript meisterneine schrittweise Node.js-Anleitung

E-Commerce-Seiten gehören zu den reichhaltigsten Quellen öffentlich strukturierter Daten im Web. Jedes Produktlisting enthält einen Titel, einen Preis, eine Bewertung, einen Verfügbarkeitsstatus und ein Bild, und diese Daten treiben Preisbeobachtung, Wettbewerbsforschung, Bestandsüberwachung und Marktanalysen an. Das Problem ist, dass moderne Storefronts den Großteil dieser Details per JavaScript rendern und ihre Seiten gegen automatisierten Datenverkehr absichern, sodass eine einfache HTTP-Anfrage in der Regel eine fast leere Shell statt des gesuchten Katalogs zurückgibt.

Diese Anleitung ist eine schrittweise Node.js-Einführung zum zuverlässigen Crawlen von Produktdaten einer E-Commerce-Seite. Sie bauen einen kleinen, lauffähigen Scraper, der eine gerenderte Listing-Seite über die Crawling API abruft, jede Produktkarte mit Cheerio parst, die Paginierung durchläuft und strukturierten Output als JSON oder CSV speichert. Die gesamte Anleitung beschränkt sich auf öffentliche Produktdaten, und der Abschnitt zur Rechtslage gegen Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies in nennenswertem Umfang einsetzen.

Was Sie bauen werden

Ein Node.js-Skript, das eine öffentliche E-Commerce-Such- oder -Kategorie-URL entgegennimmt, das gerenderte HTML über die Crawling API abruft und für jedes Produkt auf der Ergebnisseite einen strukturierten Datensatz extrahiert. Wir verwenden eine Suchanfrage als durchgehendes Beispiel und extrahieren folgende Felder pro Artikel:

• Titel der Produktname, wie er auf der Karte angezeigt wird, zum Beispiel "Herren-Analog-Armbanduhr".
• Preis der angegebene Preis, wie er angezeigt wird, zum Beispiel "Rs. 1.299".
• Bewertung die neben dem Produkt angezeigte Rezensionsanzahl oder Sternebewertung.
• Verfügbarkeit das Lager- oder Standortsignal, das eine Karte anzeigt, wenn vorhanden.
• Bild die Vorschaubild-URL des Produkts.
• Produkt-URL der Link zur einzelnen Produktseite.

Warum eine einfache Anfrage auf E-Commerce-Seiten scheitert

Wenn Sie eine Storefront-Such-URL mit einem einfachen HTTP-Client anfragen, erhalten Sie in der Regel eine Antwort mit Status 200 und nur einem Teil der Listing-Daten im Body. Zwei Dinge arbeiten gegen Sie. Erstens rendern die meisten E-Commerce-Seiten Preise, Bewertungen und den Großteil jeder Produktkarte im Browser mit JavaScript und AJAX, sodass das anfängliche HTML unvollständig ist, bis die Skripte der Seite ausgeführt wurden. Zweitens kennzeichnen Retail-Plattformen automatisierten Datenverkehr schnell: Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden herausgefordert, gedrosselt oder blockiert, bevor sie jemals den gerenderten Inhalt erreichen.

Ein funktionierender E-Commerce-Crawler benötigt also zwei Dinge in einer einzigen Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher erkennt. Sie können das selbst mit einem Headless-Browser und einem Pool rotierender Residential-Proxys zusammenbauen, aber die Integration und Wartung dieser Komponenten ist der Hauptteil der Arbeit. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie senden die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück. Für einen tieferen Einblick, warum sich clientseitig gerenderte Ziele so verhalten, lesen Sie JavaScript-Websites crawlen.

Voraussetzungen

Bevor Sie Code schreiben, müssen einige Dinge vorhanden sein. Keine davon nimmt viel Zeit in Anspruch.

JavaScript- und Node.js-Grundkenntnisse. Sie sollten damit vertraut sein, ein Node-Skript zu schreiben, auszuführen und Pakete mit npm zu installieren. Falls Sie neu in Node sind, bringen Sie die offizielle Dokumentation und jeder Einsteigerkurs auf das Niveau, das dieses Tutorial voraussetzt. Für eine ausführlichere Einführung lesen Sie unsere Anleitung zum Aufbau eines Web-Scrapers mit Node.js.

Node.js 16 oder höher. Überprüfen Sie Ihre Version mit node --version. Falls Sie es nicht haben, installieren Sie die neueste LTS-Version von der Node.js-Website oder über einen Versionsmanager wie nvm. NPM wird gebündelt mit Node.js geliefert, sodass die Installation des einen Ihnen beide gibt.

Ein Crawlbase-Konto und JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token (JS-Token) von der Kontodokumentationsseite. Crawlbase stellt zwei Token aus: das normale Token für statische Seiten und das JS-Token für dynamische, JavaScript-gerenderte Seiten. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, halten Sie es daher aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie einen Projektordner, initialisieren Sie ihn als npm-Paket und installieren Sie die Bibliotheken, die der Scraper benötigt. Das Flag npm init -y akzeptiert alle Standardwerte und schreibt eine package.json für Sie.

node --version

mkdir ecommerce-crawling && cd ecommerce-crawling
npm init -y

npm install crawlbase cheerio csv-writer

Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Node-Client für die Crawling API, cheerio parst das zurückgegebene HTML mit einer jQuery-ähnlichen API, sodass Sie einzelne Felder per CSS-Selektor extrahieren können, und csv-writer wandelt die strukturierten Datensätze am Ende in eine CSV-Datei um. Wenn Sie neu bei Selektoren sind, ist die Einführung zu XPath- und CSS-Selektoren eine gute Ergänzung.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertige Seite zu laden. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fragen Sie die Such-URL an. Die Überprüfung des Statuscodes vor dem Parsen macht Fehler laut statt still. Die Option page_wait wartet eine feste Anzahl von Millisekunden nach dem Laden, damit spät gerenderte Produktkarten vor der Aufnahme der Seite erscheinen.

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

// Replace with your actual Crawlbase JS token
const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

async function crawl(pageUrl) {
  const options = { ajax_wait: 'true', page_wait: 5000 };
  const response = await api.get(pageUrl, options);
  if (response.statusCode === 200) {
    return response.body;
  }
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

const searchUrl = 'https://example-shop.com/catalog/?q=watches+for+men';
crawl(searchUrl).then((html) => {
  console.log(html ? html.slice(0, 500) : 'No HTML returned');
});

Die beiden Warte-Optionen sind wichtig für einen clientseitig gerenderten Storefront. ajax_wait weist die API an, auf den Abschluss asynchroner Inhalte zu warten, und page_wait wartet 5000 Millisekunden (5 Sekunden) nach dem Laden, damit spät gerenderte Elemente vor der Aufnahme erscheinen. Fünf Sekunden sind ein sinnvoller Ausgangswert; erhöhen Sie ihn, wenn Preise oder Bewertungen leer zurückkommen. Das JS-Token garantiert außerdem IP-Rotation im Hintergrund, sodass die Anfrage als echter Besucher gelesen wird. Führen Sie das Skript mit node scraper.js aus, und Sie sollten echtes Produkt-Markup sehen, keine abgespeckte Shell. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben. Für eine Auffrischung der Anfrageschicht selbst lesen Sie HTTP-Anfragen in Node.js stellen.

Schritt 2: Die Selektoren identifizieren und jedes Produkt parsen

Untersuchen Sie zunächst eine Live-Produktkarte, bevor Sie etwas extrahieren. Klicken Sie mit der rechten Maustaste auf einen Titel, Preis oder eine Bewertung in Ihrem Browser und wählen Sie "Untersuchen", um die Entwicklertools zu öffnen; lesen Sie dann die Klassennamen und Tags ab, die jedes Feld umhüllen. E-Commerce-Seiten legen jedes Ergebnis in einem sich wiederholenden Block an, sodass Sie jede Karte auswählen und dann Titel, Preis, Bewertung, Bild und den Produkt-Link von innen lesen. Das defensive Lesen jedes Felds verhindert, dass ein fehlender Wert den Lauf zum Absturz bringt.

const cheerio = require('cheerio');

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

  $('div[data-qa-locator="general-products"] div[data-qa-locator="product-item"]').each((index, element) => {
    const card = $(element);
    const product = {};

    product.productPageUrl = card.find('.mainPic--ehOdr a').attr('href') || null;
    product.thumbnailImage = card.find('.mainPic--ehOdr img').attr('src') || null;
    product.title = card.find('.info--ifj7U .title--wFj93 a').text().trim() || null;
    product.price = card.find('.info--ifj7U .price--NVB62 span').text().trim() || null;
    product.noOfReviews = card.find('.info--ifj7U .rateAndLoc--XWchq .rating__review--ygkUy').text().trim() || null;
    product.location = card.find('.info--ifj7U .rateAndLoc--XWchq .location--eh0Ro').text().trim() || null;

    if (product.title) results.push(product);
  });

  return results;
}

Ein paar Details machen das robust. Jedes Feld fällt auf null zurück, wenn das Element fehlt, was häufig vorkommt, da nicht jede Karte eine Bewertung oder eine Standortzeile zeigt. Die Produkt-URL und das Bild werden aus dem href des Ankers und dem src des Bildes gelesen, nicht aus ihrem Text, weshalb sie attr statt text verwenden. Der äußere Selektor zielt auf das Produktraster über seine data-qa-locator-Attribute, die tendenziell stabiler sind als die gehashten Klassennamen, und die abschließende Prüfung if (product.title) überspringt leere oder Platzhalterblöcke.

Schritt 3: Den Crawler zusammenfügen

Verbinden Sie nun Abruf und Parsen zu einem lauffähigen Skript. Rufen Sie das gerenderte HTML ab, übergeben Sie es an den Parser und geben Sie die strukturierten Datensätze aus. Dies ist die kleinste End-to-End-Version, die eine einzelne Suchseite crawlt.

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

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

async function crawl(pageUrl) {
  const options = { ajax_wait: 'true', page_wait: 5000 };
  const response = await api.get(pageUrl, options);
  if (response.statusCode === 200) return response.body;
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

function parseSearch(html) {
  const $ = cheerio.load(html);
  const results = [];
  $('div[data-qa-locator="general-products"] div[data-qa-locator="product-item"]').each((index, element) => {
    const card = $(element);
    const product = {
      productPageUrl: card.find('.mainPic--ehOdr a').attr('href') || null,
      thumbnailImage: card.find('.mainPic--ehOdr img').attr('src') || null,
      title: card.find('.info--ifj7U .title--wFj93 a').text().trim() || null,
      price: card.find('.info--ifj7U .price--NVB62 span').text().trim() || null,
      noOfReviews: card.find('.info--ifj7U .rateAndLoc--XWchq .rating__review--ygkUy').text().trim() || null,
      location: card.find('.info--ifj7U .rateAndLoc--XWchq .location--eh0Ro').text().trim() || null,
    };
    if (product.title) results.push(product);
  });
  return results;
}

async function main() {
  const searchUrl = 'https://example-shop.com/catalog/?q=watches+for+men';
  const html = await crawl(searchUrl);
  if (!html) return;
  const results = parseSearch(html);
  console.log(JSON.stringify(results.slice(0, 3), null, 2));
}

main();

Die Funktion main erstellt die Such-URL für die Anfrage, sendet sie mit einem 5-Sekunden-Seiten-Warte durch die Crawling API, damit das JavaScript-Rendering abgeschlossen wird, und parst das zurückgegebene HTML mit Cheerio. Die extrahierten Datensätze, einschließlich Produkt-URLs, Bilder, Titel, Preise, Rezensionsanzahlen und Standorte, werden in einem Array gesammelt und zur Überprüfung protokolliert. Führen Sie es mit node scraper.js aus, um zu bestätigen, dass die Felder befüllt zurückkommen.

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript aus, und Sie erhalten ein sauberes Array von Datensätzen, einen pro Produkt, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

[
  {
    "productPageUrl": "https://example-shop.com/products/mens-analog-watch-1.html",
    "thumbnailImage": "https://img.example-shop.com/p/mens-analog-watch-1.jpg",
    "title": "Men's Analog Wrist Watch Stainless Steel",
    "price": "Rs. 1,299",
    "noOfReviews": "(128)",
    "location": "Karachi"
  },
  {
    "productPageUrl": "https://example-shop.com/products/sport-digital-watch-2.html",
    "thumbnailImage": "https://img.example-shop.com/p/sport-digital-watch-2.jpg",
    "title": "Sport Digital Watch Waterproof",
    "price": "Rs. 899",
    "noOfReviews": "(54)",
    "location": "Lahore"
  }
]

Schritt 4: Paginierung über Listing-Seiten hinweg behandeln

Eine Seite Ergebnisse ist eine Demo; ein echter Job durchläuft die Paginierung. E-Commerce-Suchergebnisse sind auf viele Seiten verteilt; um einen vollständigen Katalog zu sammeln, lesen Sie zunächst die Gesamtseitenanzahl aus und iterieren Sie dann von Seite 1 bis Seite N, wobei Sie jede Seite abrufen und parsen. Die Gesamtzahl wird in der Regel durch das Paginierungssteuerelement am unteren Rand der ersten Seite angezeigt; Sie können sie mit einem Selektor auslesen und in eine Zahl umwandeln. Jede Seiten-URL fügt der Such-URL einfach einen Parameter &page= hinzu.

async function getTotalPages(query) {
  const searchUrl = `https://example-shop.com/catalog/?q=${encodeURIComponent(query)}`;
  const html = await crawl(searchUrl);
  if (!html) return 0;
  const $ = cheerio.load(html);
  const totalPages = parseInt($('ul.ant-pagination li:nth-last-child(2)').attr('title'), 10);
  return Number.isNaN(totalPages) ? 1 : totalPages;
}

async function crawlPage(query, page) {
  const searchUrl = `https://example-shop.com/catalog/?q=${encodeURIComponent(query)}&page=${page}`;
  const html = await crawl(searchUrl);
  return html ? parseSearch(html) : [];
}

async function crawlAll(query) {
  const totalPages = await getTotalPages(query);
  const results = [];
  for (let page = 1; page <= totalPages; page++) {
    const pageResults = await crawlPage(query, page);
    results.push(...pageResults);
  }
  return results;
}

Der Ablauf ist in drei kleine Funktionen aufgeteilt. getTotalPages ruft die erste Suchseite ab und liest die Seitenanzahl aus dem Paginierungssteuerelement aus, mit Fallback auf 1, wenn der Wert fehlt. crawlPage ruft eine einzelne Seite ab und parst sie, indem der Parameter page an die URL angehängt wird. crawlAll verknüpft beides: Es ermittelt die Gesamtzahl, durchläuft eine Schleife von Seite 1 bis N und aggregiert die Ergebnisse jeder Seite in einem Array. Da jede Ergebnisseite dieselbe Kartenstruktur teilt, funktioniert die bereits geschriebene Funktion parseSearch über alle Seiten hinweg ohne Änderungen. Begrenzen Sie bei sehr großen Katalogen die Schleife auf eine sinnvolle Anzahl von Seiten, anstatt Tausende in einem Lauf zu crawlen.

Schritt 5: Die Daten als CSV speichern

Wenn die Datensätze gesammelt sind, schreiben Sie sie in eine CSV-Datei, damit Sie die Daten in einer Tabellenkalkulation öffnen oder in ein anderes Tool laden können. Die Bibliothek csv-writer ermöglicht es Ihnen, Header zu definieren, die Ihren Feldnamen zugeordnet sind, und alle Datensätze in einem einzigen Aufruf zu schreiben. JSON und CSV haben jeweils ihren Platz; die Anleitung zu E-Commerce Web Scraping erläutert, wann welches Format zu bevorzugen ist.

const createCsvWriter = require('csv-writer').createObjectCsvWriter;

const csvWriter = createCsvWriter({
  path: 'ecommerce_products.csv',
  header: [
    { id: 'productPageUrl', title: 'Product Page URL' },
    { id: 'thumbnailImage', title: 'Thumbnail Image URL' },
    { id: 'title', title: 'Title' },
    { id: 'price', title: 'Price' },
    { id: 'noOfReviews', title: 'Number of Reviews' },
    { id: 'location', title: 'Location' },
  ],
});

async function saveToCsv(data) {
  await csvWriter.writeRecords(data);
}

(async () => {
  const products = await crawlAll('watches for men');
  await saveToCsv(products);
  console.log(`Saved ${products.length} products to ecommerce_products.csv`);
})();

Das Header-Array ordnet jede Feld-ID einem menschenlesbaren Spaltentitel zu, sodass die resultierende CSV sauber in Excel oder Google Sheets geöffnet wird, mit beschrifteten Spalten. Wenn Sie dieselben Datensätze stattdessen in einer Datenbank speichern möchten, lassen sich die strukturierten Objekte direkt auf Tabellenzeilen abbilden: behalten Sie dieselben Feldnamen als Spalten und fügen Sie eine Zeile pro Produkt ein. Die Form der Daten ändert sich nicht, nur das Ziel.

Skalieren und nicht blockiert werden

Selbst mit erledigendem Rendering beobachten Retail-Plattformen Datenverkehr mit Scraper-Muster. Ein paar Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes hart umkämpfte kommerzielle Ziel.

• Anfragen dosieren. Seiten in engem Takt zu bombardieren ist der schnellste Weg, gedrosselt zu werden. Verteilen Sie Anfragen und variieren Sie Ihre Anfragen, anstatt einen Pfad mit Höchstgeschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool von Residential-IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API erledigt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig hinbekommen müssen.
• Statuscodes lesen. Ein Lauf, der anfängt, Herausforderungen oder Fehler zurückzugeben, zeigt Ihnen, dass die aktuelle Rate oder IP-Ebene nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückrudern, nicht als Rauschen.
• Cachen und deduplizieren. Speichern Sie das gerenderte HTML oder die geparsten Zeilen, damit ein erneuter Lauf keine bereits abgerufenen Seiten neu lädt; das hält sowohl Ihre Kosten als auch Ihr Anfragevolumen niedrig.

Das umfassende Handbuch finden Sie unter Websites scrapen ohne blockiert zu werden. Wenn Sie Ihren eigenen Datenverkehr lieber über einen rotierenden Pool leiten möchten, anstatt die verwaltete API zu nutzen, bietet der Smart AI Proxy dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt. Das Abruf-dann-Parse-Muster in dieser Anleitung überträgt sich auf die meisten Storefronts: Nur die Selektoren und der Paginierungsparameter ändern sich von einer Seite zur nächsten.

Ist es legal, E-Commerce-Seiten zu crawlen?

Ob das Crawlen einer E-Commerce-Seite erlaubt ist, hängt von den Nutzungsbedingungen der jeweiligen Seite, Ihrer Jurisdiktion und dem ab, was Sie mit den Daten tun. Viele Storefronts schränken den automatisierten Zugriff in ihren Nutzungsbedingungen ein, sodass Crawling unabhängig von der Sorgfalt Ihrer Werkzeuge gegen diese Bedingungen verstoßen kann. Kein Code hier ändert das; er lässt nur den technischen Teil funktionieren. Lesen Sie die Nutzungsbedingungen der Seite und ihre robots.txt, und behandeln Sie beide als die Grenze dessen, was und wie oft Sie sammeln.

Ein paar Grundsätze, an denen man festhalten sollte. Sammeln Sie nur öffentliche Produktdaten: Titel, Preis, Bewertung, Verfügbarkeit, Bild und den Produkt-Link, den jeder ohne Konto sehen kann. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie die Server der Seite nicht belasten, und respektieren Sie etwaige Rate-Erwartungen. Bleiben Sie von allem hinter einem Login fern, einschließlich Kontoseiten, Warenkörben und Bestellverlauf, und vermeiden Sie personenbezogene Daten, die identifizierbaren Käufern oder Verkäufern zuzuordnen sind. Verteilen Sie keine urheberrechtlich geschützten Medien wie Produktfotografien oder Beschreibungen auf eine Art, für die die Seite keine Lizenz erteilt hat; deren kommerzielle Wiederverwendung ist eine andere Frage als das Lesen eines öffentlichen Preises.

Für großes Volumen oder kommerzielle Nutzung bevorzugen Sie einen offiziellen Kanal, wo einer vorhanden ist. Viele große Einzelhändler und Marktplätze veröffentlichen offizielle Produkt- oder Affiliate-APIs, die Ihnen garantierte Struktur und klare Nutzungsrechte bieten; das sind die richtigen Werkzeuge, wenn Sie große Mengen oder kommerzielle Wiederverwendung benötigen. Diese Anleitung beschränkt sich bewusst auf öffentliche Listing- und Suchseiten, weil das die Grenze ist, die die Arbeit vertretbar macht. Sie behandelt nichts hinter der Authentifizierung, keine personenbezogenen Daten, keine privaten Konto- oder Bestellinformationen und keinen Versuch, einen Login zu umgehen. Wenn Ihr Projekt mehr als öffentliche Listings benötigt, ist eine offizielle API oder eine Datenvereinbarung der richtige Weg, kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Was ist der Unterschied zwischen Web-Crawling und Web-Scraping?

Web-Crawling ist der Prozess, eine Seite systematisch zu durchsuchen und Daten über viele Seiten hinweg zu sammeln, indem Links und Paginierung verfolgt werden. Web-Scraping ist die Extraktion bestimmter Felder, wie Preis oder Titel, von einer gegebenen Seite. In der Praxis arbeiten beide zusammen: Der Crawler durchläuft die Listing-Seiten, und der Scraping-Schritt extrahiert die strukturierten Felder aus jeder Seite. Das Skript in dieser Anleitung erledigt beides.

Warum gibt eine einfache Anfrage unvollständige Daten von E-Commerce-Seiten zurück?

Weil die meisten Storefronts Preise, Bewertungen und den Großteil jeder Produktkarte clientseitig mit JavaScript und AJAX rendern. Das anfängliche HTML ist unvollständig, bis die Skripte der Seite in einem Browser ausgeführt werden; eine direkte HTTP-Anfrage gibt also Status 200 mit fehlenden oder leeren Schlüsselfeldern zurück. Um eine vollständige Seite zu erhalten, müssen Sie sie zuerst rendern, was das JS-Token der Crawling API für Sie übernimmt.

Brauche ich das normale Token oder das JS-Token?

Verwenden Sie das JS-Token für E-Commerce-Such- und Listing-Seiten. Das normale Token ruft statisches HTML ab, das auf einem clientseitig gerenderten Storefront mit fehlenden Preisen oder Bewertungen zurückkommen kann. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, und ermöglicht die Übergabe von Warte-Parametern wie ajax_wait und page_wait, sodass dynamisch geladene Karten vorhanden sind, wenn Cheerio sie parst.

Meine Selektoren geben null zurück. Was hat sich geändert?

Mit ziemlicher Sicherheit das Markup der Seite. Die gehashten Klassennamen, die Storefront-Build-Tools generieren, ändern sich ohne Vorankündigung, und sie unterscheiden sich zwischen Such- und einzelnen Produktseiten; Selektoren, die letzten Monat funktioniert haben, können daher kaputtgehen. Untersuchen Sie eine Live-Seite in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren, wobei Sie sich auf stabile Attribute wie data-qa-locator stützen, wo sie vorhanden sind. Regelmäßige Selektor-Pflege ist bei jedem produktiven Scraper normal.

Wie speichere ich die gescrapten Produktdaten?

Für ein schnelles Ergebnis schreiben Sie die Datensätze mit csv-writer in eine CSV-Datei, sodass die Daten in jeder Tabellenkalkulation geöffnet werden können. Für wiederholte oder größere Läufe fügen Sie dieselben strukturierten Objekte in eine Datenbank ein, wobei Sie Ihre Feldnamen als Spalten und eine Zeile pro Produkt behalten. Die Datensatzform bleibt in beiden Fällen gleich; nur das Ziel ändert sich, sodass Sie mit CSV beginnen und später zu einer Datenbank wechseln können, ohne den Parser neu zu schreiben.

Wie vermeide ich Blockierungen beim Crawlen von E-Commerce-Seiten?

Halten Sie Ihre IP-spezifische Anfragerate niedrig, variieren Sie Ihre Anfragen, anstatt einen Pfad zu schleifen, und routen Sie durch rotierende Residential-IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet die Rotation und einen vertrauenswürdigen IP-Pool für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Statuscodes und rudern Sie zurück, wenn Sie Herausforderungen sehen, anstatt durchzudrücken.

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.