Zum Inhalt springen
Zurück zum Blog

Web-Scraping mit JavaScript und Node.js: Ein praktischer Leitfaden

Robert SfichiZuletzt aktualisiert am 23 min read
Web-Scraping mit JavaScript und Node.js: Ein praktischer Leitfaden
Kurzfassung: Web-Scraping mit JavaScript und Node.js erfordert Node.js 22.12 oder neuer, das integrierte fetch für Anfragen und Cheerio zum Parsen von HTML. Verwenden Sie Cheerio, wenn die Daten im HTML stehen, das Ihre Anfrage erhält, und Playwright, wenn JavaScript die Seite aufbaut oder Klicks und Wartezeiten nötig sind. Dieser Leitfaden baut einen Scraper – von Paginierung und verstecktem JSON bis zu Offline-Tests und einer Scraper-API als Fallback.

Web-Scraping mit JavaScript beginnt mit einer einfachen Aufgabe: Die Daten befinden sich auf einer Webseite, Sie schreiben JavaScript und möchten diese Daten als sauberes JSON erhalten, ohne sich mit Blöcken oder leeren Arrays herumschlagen zu müssen. Falls Ihnen dieses Konzept noch neu ist, lesen Sie zunächst nach, was Web-Scraping überhaupt ist.

Dieser Leitfaden verwendet books.toscrape.com, einen für Scraper entwickelten Übungsbuchladen, als Beispiel. Du wirst eine Seite mit nativem fetch und Cheerio abrufen und auswerten, einen paginierten Katalog behutsam durchforsten, prüfen, ob eine Seite mit JavaScript aufgebaut wird, Seiten mit Playwright rendern und durchklicken, Ihren Parser offline testen und blockierte Seiten an eine Scraper-API weiterleiten, ohne den Parser zu ändern.

Schnellstart

  • Verwende Node.js 22.12 oder höher (24 oder 26 LTS empfohlen)
  • npm install cheerio für Seiten, deren Daten im HTML-Code enthalten sind
  • npm install playwright für Seiten, die einen echten Browser erfordern
  • Überprüfen Sie vor dem Crawlen die robots.txt-Datei und die Nutzungsbedingungen der Website

Was benötigst du, um mit dem Web-Scraping mit JavaScript zu beginnen?

Du benötigst Node.js 22.12 oder höher, einen Code-Editor und zwei Pakete: Cheerio zum Parsen von HTML und Playwright zum Rendern von Seiten, für die ein Browser erforderlich ist. Die in Node integrierte `fetch`-Funktion wickelt die Anfragen ab, sodass du Axios nicht benötigst. Machen Sie sich auch mit den DevTools Ihres Browsers vertraut, denn das Finden des richtigen Selektors und der Datenquelle der Seite ist schon die halbe Arbeit.

Node.js eignet sich gut für Scraper. Es spricht dieselbe Sprache wie die Skripte der Seite selbst, sodass das Lesen des JavaScript einer Website vertraut wirkt. Sein asynchrones E/A-Modell verarbeitet viele Netzwerkanfragen ohne Threads. Und die führenden Tools zur Browser-Automatisierung, Playwright und Puppeteer, sind JavaScript-basiert.

Die folgende Tabelle listet die in diesem Leitfaden verwendeten Tools auf. Eine umfassendere Übersicht findest du im Vergleich von sechs Node.js-Scraping-Bibliotheken.

Tool

Aufgabe

Verwenden Sie es, wenn

Aktuellste Version auf npm (Okt. 2026)

Node.js

fetch (integriert)

HTTP-Anfragen

Immer; keine Installation erforderlich

Teil von Node

Stabil seit Node 21

Cheerio

HTML mit CSS-Selektoren analysieren

Die Daten befinden sich im HTML-Code

1.2.0

20.18.1

jsdom

Ein browserähnliches DOM in Node

Sie benötigen DOM-APIs, nicht nur Selektoren

30.1.3

22.22.2, 24.15 oder 26

Playwright

Steuert Chromium, Firefox und WebKit

Seiten erfordern Klicks, Wartezeiten oder das Rendern

1.64.1

20

Puppeteer

Chrome oder Firefox steuern

Bestehender Puppeteer-Code, Chrome-Tools

25.16.0

22.12.0

p-limit

Begrenzung der Anzahl gleichzeitiger Promises

Viele URLs auf Websites, die parallele Anfragen zulassen

7.3.3

20

Axios / Got

HTTP-Clients mit Zusatzfunktionen

Sie nutzen sie bereits

1.21.0 / 16.1.0

— / 22

jsdom erstellt ein umfassenderes DOM als Cheerio, ist jedoch langsamer und führt Seitenskripte nur mit einer Option aus, die in der eigenen Dokumentation als „unsicher“ bezeichnet wird. Daher ist Cheerio die bessere Standardwahl. Axios ist in Ordnung, wenn Ihr Projekt es bereits verwendet. Die Node-Versionsangaben erklären die Versionsempfehlung: Puppeteer benötigt 22.12, und Node 20 hat laut dem Node.js-Release-Zeitplan das Ende seiner Lebensdauer überschritten.

Wie richtet man ein Node.js-Scraping-Projekt ein?

Erstelle einen Ordner, stelle das Projekt auf ES-Module um, sodass import auch die Skripte auf oberster Ebene await funktionieren, und installiere die beiden Hauptpakete. Playwright lädt mit einem zusätzlichen Befehl seinen eigenen Chromium-Build herunter.

mkdir node-scraper && cd node-scraper
npm init -y
npm pkg set type=module
npm install cheerio playwright
npx playwright install chromium
mkdir fixtures out
# Optional, for the Puppeteer example:
npm install puppeteer

Der fixtures/ Ordner enthält gespeicherte Seiten für Offline-Tests, und out/ enthält die Ergebnisse. Puppeteer lädt Chrome während der Installation herunter, und npm 11 gibt möglicherweise eine Warnung bezüglich der Installationsskripte aus. Sie können diese Skripte mit npm install-scripts ls. Wenn Sie TypeScript verwenden, läuft derselbe Code in .ts Dateien über das in Node integrierte Type-Stripping oder einen Runner wie tsx.

Kann man eine Website mit JavaScript im Browser scrapen?

Nur auf Seiten derselben Website. Browser verhindern, dass JavaScript einer Website Antworten von einer anderen Website ausliest, es sei denn, der Server erlaubt dies über CORS-Header – was bei den meisten nicht der Fall ist. Deshalb laufen Scraper in Node.js, wo es diese Einschränkung nicht gibt. Verwenden Sie Browser-JavaScript zum Testen von Selektoren in der DevTools-Konsole, nicht zum Sammeln von Daten.

Die Regel dahinter ist die Same-Origin-Policy. Ein von einer Herkunft geladenes Skript kann eine Anfrage an eine andere senden, aber der Browser verbirgt die Antwort, es sei denn, der andere Server gibt dies mit Access-Control-Allow-Origin Header zustimmt. Der CORS-Leitfaden von MDN erläutert die Details.

Node.js ist kein Browser und liest daher jede Antwort, die es erhält. Das macht es zum idealen Ort für einen Scraper und sorgt dafür, dass Anmeldedaten wie API-Schlüssel nicht auf den Rechnern der Besucher gespeichert werden. Browser-Erweiterungen und Bookmarklets bilden die einzige Ausnahme: Sie können die Seite lesen, die du gerade ansiehst, was sich für einmaliges Kopieren eignet, nicht jedoch für eine geplante Datenerfassung.

Wie scrapt man eine Webseite mit Node.js fetch und Cheerio?

Rufe den HTML-Code der Seite mit `fetch()` ab, überprüfe, ob die Antwort in Ordnung ist, und lade den Text mit `cheerio.load()` in Cheerio. Wähle jede sich wiederholende Karte oder Zeile mit einem CSS-Selektor aus, lese Text oder Attribute daraus aus und konvertiere Zahlen dabei. Gib einfache Objekte zurück und löse relative Links mit `new URL(href, pageUrl)` auf.

books.toscrape.com listet 1.000 Bücher auf 50 Katalogseiten auf, 20 pro Seite, mit Preisen, Sternebewertungen und Verfügbarkeitsstatus. Ein Banner auf der Website weist darauf hin, dass es sich um eine Demo zum Üben des Scrapings handelt und dass Preise und Bewertungen zufällig sind – es ist also ein sicherer Ort zum Lernen.

Beginnen Sie mit einem Abruf-Helper, den Sie überall wiederverwenden können. Er sendet einen aussagekräftigen User-Agent, gibt nach 15 Sekunden auf und AbortSignal.timeout(), prüft res.okund versucht es bei Ratenbeschränkungen und Serverfehlern erneut. Wenn der Server den „Retry-After“-Header sendet, wartet er so lange. Andernfalls wendet er ein exponentielles Backoff an.

// fetch-html.js: one polite GET with a timeout, a status check, and retries
const HEADERS = {
  'User-Agent': 'node-scraper-tutorial/1.0 (+https://example.com/contact)',
  'Accept': 'text/html,application/xhtml+xml',
  'Accept-Language': 'en-US,en;q=0.9',
};
const RETRY = new Set([429, 500, 502, 503, 504]);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function fetchHtml(url, { retries = 3, timeoutMs = 15_000 } = {}) {
  for (let attempt = 0; ; attempt++) {
    let res;
    try {
      res = await fetch(url, { headers: HEADERS, signal: AbortSignal.timeout(timeoutMs) });
    } catch (err) {                                   // DNS, reset, or timeout
      if (attempt >= retries) throw err;
      await sleep(1000 * 2 ** attempt);
      continue;
    }
    if (res.ok) return res.text();
    if (!RETRY.has(res.status) || attempt >= retries) {
      throw new Error(`GET ${url} failed: HTTP ${res.status}`);
    }
    const retryAfter = Number(res.headers.get('retry-after'));  // seconds, if the server says so
    await sleep(retryAfter > 0 ? retryAfter * 1000 : 1000 * 2 ** attempt);
  }
}

Ersetze die Kontakt-URL durch deine eigene, damit ein Website-Betreiber dich erreichen kann, anstatt dich zu blockieren. fetch ist in Node integriert, und die Fetch-API funktioniert genauso wie im Browser. Wenn du stattdessen eine Bibliothek in Betracht ziehst, sieh dir den Vergleich zwischen „native fetch“, Axios, Got und Ky an.

Der Parser nimmt HTML und die URL der Seite entgegen und gibt typisierte Datensätze zurück. Da er frei von Netzwerkcode ist, lässt er sich leicht testen und bei Änderungen an der Abrufmethode einfach wiederverwenden.

// parse-books.js: turn one books.toscrape.com listing page into typed records
import * as cheerio from 'cheerio';

const RATINGS = { One: 1, Two: 2, Three: 3, Four: 4, Five: 5 };

export function parseBooks(html, pageUrl) {
  const $ = cheerio.load(html);

  const books = $('article.product_pod').map((_, card) => {
    const $card = $(card);
    const link = $card.find('h3 a');
    const priceText = $card.find('.price_color').text();          // "£51.77"
    const ratingWord = ($card.find('.star-rating').attr('class') ?? '')
      .replace('star-rating', '').trim();                          // "Three"

    return {
      title: link.attr('title'),                    // full title; the link text is cut off
      price: priceText ? Number(priceText.replace(/[^0-9.]/g, '')) : null,
      currency: priceText.includes('£') ? 'GBP' : null,
      rating: RATINGS[ratingWord] ?? null,
      inStock: $card.find('.instock.availability').length > 0,
      url: new URL(link.attr('href'), pageUrl).href, // hrefs are relative, and differ by page
    };
  }).get();

  const nextHref = $('li.next a').attr('href');
  const nextUrl = nextHref ? new URL(nextHref, pageUrl).href : null;
  return { books, nextUrl };
}

Die Ausgabe benötigt keinen zweiten Bereinigungsdurchlauf. Der Preis wird zu einer Zahl, nicht zu einer Zeichenkette "£51.77". Die Sternebewertung ist im Klassennamen enthalten (star-rating Three), sodass eine kleine Zuordnung sie in Werte von 1 bis 5 umwandelt und alles Unerwartete null statt zu einer falschen Vermutung. Und jeder Link wird über new URL(), da die `hrefs` der Website relativ sind.

Speichere eine Kopie der ersten Katalogseite und führe den Parser darauf aus, ohne dass eine Netzwerkverbindung erforderlich ist:

curl -o fixtures/books-page-1.html "https://books.toscrape.com/catalogue/page-1.html"
// static-fixture.js: parse a saved page, no network
import { readFile } from 'node:fs/promises';
import { parseBooks } from './parse-books.js';

const html = await readFile('fixtures/books-page-1.html', 'utf8');
const { books, nextUrl } = parseBooks(html, 'https://books.toscrape.com/catalogue/page-1.html');
console.log(books.length, 'books');
console.log(books[0]);
console.log('next:', nextUrl);

Ausgabe:

20 books
{
  title: 'A Light in the Attic',
  price: 51.77,
  currency: 'GBP',
  rating: 3,
  inStock: true,
  url: 'https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html'
}
next: https://books.toscrape.com/catalogue/page-2.html

Speichere jeden Seitentyp, den du scrapen möchtest, auf dieselbe Weise – jeweils eine curl -o pro Seite im Abstand von einer Sekunde. Diese Dateien dienen später als Test-Fixtures. Cheerio hat noch mehr zu bieten, darunter extract() das Auslesen von JSON aus Script-Tags. Beides wird in unserem vollständigen Cheerio-Leitfaden behandelt, und die Dokumentation von Cheerio listet die gesamte API auf.

Wie findest du die richtigen CSS-Selektoren?

Öffne die Seite in deinem Browser, klicke mit der rechten Maustaste auf die gewünschten Daten und wähle „Inspect“ aus. Suche das Element, das sich einmal pro Datensatz wiederholt, beispielsweise eine Produktkarte mit einer Klasse, und teste deinen Selektor in der DevTools-Konsole mit `document.querySelectorAll()`. Verwende kurze, klassenbasierte Selektoren anstelle langer Pfade, die aus den DevTools kopiert wurden, da diese bei Layoutverschiebungen nicht mehr funktionieren.

Auf books.toscrape.com klickst du mit der rechten Maustaste auf einen beliebigen Buchtitel und wählst „Inspect“ aus. Jedes Buch befindet sich in einem <article class="product_pod">, das ist also das sich wiederholende Element. Testen Sie es auf der Registerkarte „Konsole“:

document.querySelectorAll('article.product_pod').length   // 20
document.querySelector('article.product_pod h3 a').textContent   // "A Light in the ..."
document.querySelector('article.product_pod h3 a').title         // "A Light in the Attic"

Die zweite Zeile zeigt eine Falle, die leicht zu übersehen ist. Lange Titel werden im sichtbaren Linktext gekürzt, aber der vollständige Titel befindet sich im title . Vergleiche das, was du extrahierst, immer mit dem, was die Seite tatsächlich aussagt, und nicht nur mit dem, was sie anzeigt. Bei der Bewertung verhält es sich genauso: Nirgendwo in der Karte steht eine „3“, sondern nur die Klasse star-rating Three.

Beachten Sie auch den Unterschied zwischen „Quelltext anzeigen“ und „Inspect“. „Quelltext anzeigen“ zeigt den vom Server gesendeten HTML-Code an – genau das, was fetch empfängt. „Inspect“ zeigt das Live-DOM an, nachdem Skripte ausgeführt wurden. Wenn ein Selektor in „Inspect“ funktioniert, in Node.js jedoch nichts zurückgibt, wurde dieser Inhalt per JavaScript erstellt – die folgenden Abschnitte zeigen, was zu tun ist.

Verwenden Sie Selektoren, die auf Klassen und Attribute abzielen, anstatt auf die Position (li.next a, nicht ul > li:nth-child(2) > a). Außerdem dürfen CSS-IDs nicht mit einer Ziffer beginnen, es sei denn, sie werden mit einem Escape-Zeichen versehen; ein Element mit id="2015" muss [id="2015"] statt #2015. Für alles andere sollten Sie eine vollständige Selektor-Referenz zur Hand haben.

Wie kann man mehrere Seiten „höflich“ scrapen?

Überprüfen Sie zunächst die robots.txt und folgen Sie dann dem „Weiter“-Link jeder Seite, anstatt URL-Muster zu erraten. Führen Sie eine Liste der bereits besuchten URLs, damit ein fehlerhafter Link nicht zu einer Endlosschleife führt, entfernen Sie Duplikate anhand eines stabilen Schlüssels und warten Sie zwischen den Anfragen. Halten Sie sich an die Ratenbeschränkungen der Website und die „Retry-After“-Header ein und begrenzen Sie die Gesamtzahl der Seiten während der Entwicklung.

Beginnen Sie mit der robots.txt. Dieser minimale Reader sammelt die Disallow Regeln für die User-agent: * Gruppe. Er verarbeitet einfache Präfixregeln, während der robots.txt-Standard (RFC 9309) Platzhalter und Allow Prioritäten definiert; verwende daher einen vollständigen Parser auf Websites, die darauf zurückgreifen. Nach diesem Standard bedeutet eine 4xx-Antwort, dass keine Regeln gelten, und eine 5xx-Antwort, dass du die gesamte Website als gesperrt behandeln solltest.

// robots.js: a minimal robots.txt check for the "User-agent: *" group.
// Good enough for simple prefix rules; use a full RFC 9309 parser for wildcards or Allow precedence.
export async function disallowedPaths(origin) {
  const res = await fetch(new URL('/robots.txt', origin), { signal: AbortSignal.timeout(10_000) });
  if (res.status >= 500) throw new Error(`robots.txt HTTP ${res.status}: treat the site as off-limits`);
  if (!res.ok) return [];                       // 4xx: no robots.txt, so nothing is disallowed
  let inStar = false;
  const rules = [];
  for (const raw of (await res.text()).split('\n')) {
    const line = raw.split('#')[0].trim();
    const [key, ...rest] = line.split(':');
    const value = rest.join(':').trim();
    if (/^user-agent$/i.test(key)) inStar = value === '*';
    else if (inStar && /^disallow$/i.test(key) && value) rules.push(value);
  }
  return rules;
}

export const isAllowed = (url, rules) => !rules.some((p) => new URL(url).pathname.startsWith(p));

Der Crawler beginnt auf der ersten Katalogseite, folgt dem nächsten Link, bis kein weiterer mehr vorhanden ist, wartet eine Sekunde zwischen den Anfragen und speichert die Ergebnisse im JSON- und CSV-Format.

// crawl-books.js: follow "next" links politely and save JSON + CSV
import { writeFile } from 'node:fs/promises';
import { fetchHtml } from './fetch-html.js';
import { parseBooks } from './parse-books.js';
import { disallowedPaths, isAllowed } from './robots.js';

const START = 'https://books.toscrape.com/catalogue/page-1.html';
const MAX_PAGES = Number(process.env.MAX_PAGES ?? 5);
const DELAY_MS = 1000;                           // no published limit, so stay at one request per second

const rules = await disallowedPaths(START);
const seen = new Set();                          // stops loops if a "next" link points backward
const byUrl = new Map();                         // dedupe records, not just pages

for (let url = START, page = 1; url && page <= MAX_PAGES && !seen.has(url); page++) {
  if (!isAllowed(url, rules)) { console.log('robots.txt disallows', url); break; }
  seen.add(url);
  const { books, nextUrl } = parseBooks(await fetchHtml(url), url);
  for (const b of books) byUrl.set(b.url, b);
  console.log(`page ${page}: ${books.length} books (${url})`);
  url = nextUrl;
  if (url) await new Promise((r) => setTimeout(r, DELAY_MS));
}

const books = [...byUrl.values()];
await writeFile('out/books.json', JSON.stringify(books, null, 2));
const cols = Object.keys(books[0]);
const cell = (v) => `"${String(v ?? '').replaceAll('"', '""')}"`;
await writeFile('out/books.csv',
  [cols.join(','), ...books.map((b) => cols.map((c) => cell(b[c])).join(','))].join('\n') + '\n');
console.log(`saved ${books.length} unique books; robots.txt disallows: ${rules.join(', ') || 'nothing'}`);

Ausgabe mit der standardmäßigen Begrenzung auf fünf Seiten:

page 1: 20 books (https://books.toscrape.com/catalogue/page-1.html)
page 2: 20 books (https://books.toscrape.com/catalogue/page-2.html)
page 3: 20 books (https://books.toscrape.com/catalogue/page-3.html)
page 4: 20 books (https://books.toscrape.com/catalogue/page-4.html)
page 5: 20 books (https://books.toscrape.com/catalogue/page-5.html)
saved 100 unique books; robots.txt disallows: nothing

Führen Sie den Crawler mit MAX_PAGES=100 node crawl-books.js aus, und er stoppt von selbst nach Seite 50, da die letzte Seite keinen „Weiter“-Link enthält:

page 49: 20 books (https://books.toscrape.com/catalogue/page-49.html)
page 50: 20 books (https://books.toscrape.com/catalogue/page-50.html)
saved 1000 unique books; robots.txt disallows: nothing

Diese Website veranschaulicht, warum jede dieser Sicherheitsvorkehrungen existiert. Der „Weiter“-Link auf der Startseite lautet catalogue/page-2.html, auf Seite 2 lautet er jedoch lediglich page-3.html. Wenn man das an das Stammverzeichnis der Website anhängt, ergibt sich https://books.toscrape.com/page-3.html, was einen 404-Fehler zurückgibt. new URL(href, pageUrl) jeden Link anhand der Seite auflöst, von der er stammt, sodass das Ergebnis immer korrekt ist.

Die Startseite und catalogue/page-1.html stellen zudem dieselben 20 Bücher unter zwei URLs bereit, und beide verweisen mit ihrem nächsten Link auf Seite 2. Ein Crawler, der von beiden Seiten aus startet oder einem „Zurück“-Link zurück zu Seite 1 folgt, würde bei 20 Büchern 40 Zeilen einsparen. Die Menge der besuchten Seiten verhindert doppelte Seiten, und die Indizierung der Datensätze anhand der Buch-URL verhindert doppelte Zeilen. Weitere Tipps dieser Art findest du in unserem Leitfaden zu Best Practices beim Scraping über den gesamten Projektlebenszyklus hinweg.

Wie viele Anfragen können Sie gleichzeitig ausführen?

Die Parallelität ist eine Entscheidung, die pro Website getroffen werden muss. Wenn eine Website eine Ratenbegrenzung festlegt, halten Sie sich daran – auch wenn das bedeutet, dass jeweils nur eine Anfrage gestellt werden darf. Ist dies nicht der Fall, begrenzen Sie die Anzahl paralleler Anfragen pro Host auf ein geringes Limit, legen Sie eine Pause ein und ziehen Sie sich bei einem 429-Fehler zurück. Mehr Geschwindigkeit hilft selten, wenn Sie dadurch blockiert werden.

books.toscrape.com gibt keine Begrenzung vor, daher ruft dieses Skript jeweils zwei Buchdetailseiten gleichzeitig ab und verwendet dabei p-limit (npm install p-limit), um die UPC und die genaue Lagerbestandszahl jedes Buches hinzuzufügen:

// details.js: enrich books from their detail pages, at most 2 requests at a time
import { readFile, writeFile } from 'node:fs/promises';
import * as cheerio from 'cheerio';
import pLimit from 'p-limit';
import { fetchHtml } from './fetch-html.js';

const books = JSON.parse(await readFile('out/books.json', 'utf8')).slice(0, 10);
const limit = pLimit(2);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const results = await Promise.allSettled(books.map((book) => limit(async () => {
  const $ = cheerio.load(await fetchHtml(book.url));
  await sleep(500);                               // keep a pause even with two workers
  return {
    ...book,
    upc: $('th:contains("UPC")').next('td').text(),
    stockCount: Number($('p.instock.availability').text().match(/\d+/)?.[0] ?? 0),
  };
})));

const ok = results.filter((r) => r.status === 'fulfilled').map((r) => r.value);
console.log(`${ok.length} enriched, ${results.length - ok.length} failed`);
console.log(ok[0]);
await writeFile('out/books-details.jsonl', ok.map((b) => JSON.stringify(b)).join('\n') + '\n');

Ausgabe:

10 enriched, 0 failed
{
  title: 'A Light in the Attic',
  price: 51.77,
  currency: 'GBP',
  rating: 3,
  inStock: true,
  url: 'https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html',
  upc: 'a897fe39b1053632',
  stockCount: 22
}

Promise.allSettled() verhindert, dass eine fehlgeschlagene Seite die anderen neun Ergebnisse zunichte macht.

Wie speichert man gescrapte Daten als JSON und CSV?

JSON bewahrt Ihre Datentypen: Zahlen bleiben Zahlen und null bleiben null. CSV ist das, was Tabellenkalkulationen benötigen, erfordert jedoch Anführungszeichen; daher umschließt der Crawler jede Zelle mit Anführungszeichen und verdoppelt alle Anführungszeichen innerhalb eines Werts. Leere Werte werden zu leeren Zellen.

title,price,currency,rating,inStock,url
"A Light in the Attic","51.77","GBP","3","true","https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html"
"Tipping the Velvet","53.74","GBP","1","true","https://books.toscrape.com/catalogue/tipping-the-velvet_999/index.html"

Bei größeren Aufgaben schreiben Sie ein JSON-Objekt pro Zeile (JSON Lines), wie details.js es hier getan wird, damit ein Absturz auf halbem Weg nicht die gesamte Datei zunichte macht. Wenn Ihre Quelle eher eine Tabelle als einzelne Karten ist, lesen Sie unseren Leitfaden zum Exportieren von HTML-Tabellen in sauberes CSV.

Woran erkennt man, ob eine Seite JavaScript-Rendering benötigt?

Rufe die Seite mit einem einfachen `fetch()` auf und führe deinen Selektor aus. Wenn dieser nichts findet, der Browser die Daten aber anzeigt, baut JavaScript diesen Inhalt nach dem Laden auf. Öffne dann die DevTools, wähle den Reiter „Netzwerk“, filtere nach „Fetch/XHR“ und lade die Seite neu oder klicke darauf: Die Anfrage, die deine Daten zurückgibt, ist in der Regel einfacher zu nutzen als ein Browser.

Sie können diese Überprüfung automatisieren. Dieses Skript zählt die Treffer Ihres Selektors im Roh-HTML und auf der gerenderten Seite und listet jede „fetch“- oder XHR-Anfrage auf, die die Seite während des Ladens stellt:

// check-js.js: does the selector match in the raw HTML and in the rendered page?
import * as cheerio from 'cheerio';
import { chromium } from 'playwright';
import { fetchHtml } from './fetch-html.js';

const url = process.argv[2] ?? 'https://books.toscrape.com/catalogue/page-1.html';
const selector = process.argv[3] ?? 'article.product_pod';

const $ = cheerio.load(await fetchHtml(url));
const inHtml = $(selector).length;

const browser = await chromium.launch();
try {
  const page = await browser.newPage();
  const dataRequests = [];
  page.on('request', (req) => {
    if (['xhr', 'fetch'].includes(req.resourceType())) dataRequests.push(req.url());
  });
  await page.goto(url, { waitUntil: 'networkidle' });
  const rendered = await page.locator(selector).count();

  console.log(`raw HTML: ${inHtml} | rendered: ${rendered} | fetch/XHR requests: ${dataRequests.length}`);
  dataRequests.forEach((u) => console.log('  ', u));
  console.log(inHtml > 0 ? 'The data is in the HTML: use fetch + Cheerio.'
    : dataRequests.length ? 'JavaScript loads the data: try calling the request above.'
    : 'JavaScript builds the data: render the page or look for JSON in a <script>.');
} finally {
  await browser.close();
}

Ausgabe für den Buchkatalog:

raw HTML: 20 | rendered: 20 | fetch/XHR requests: 0
The data is in the HTML: use fetch + Cheerio.

Das ist die Antwort, auf die du hoffst: Der Server sendet jedes Buch im HTML-Code, sodass ein Browser nur zusätzliche Zeit kosten würde. Führe dasselbe Skript mit einer anderen URL und einem anderen Selektor aus (node check-js.js <url> "<selector>"), bevor du einen Scraper für eine neue Website schreibst.

Wenn die Rohzahl 0 ist, befinden sich die Daten an einer von zwei anderen Stellen. Es kann sich um JSON innerhalb eines <script> Tag, das Cheerio lesen und JSON.parse() dekodieren kann. Oder JavaScript fordert die Daten nach dem Laden ab, und die Anfrage erscheint in der Liste des Skripts sowie auf der Registerkarte „Netzwerk“. In beiden Fällen kannst du den Browser oft überspringen. Hintergrundinformationen dazu, was ein rendernender Browser tut, findest du unter „So funktionieren Headless-Browser“.

Wie kann man JavaScript-Daten ohne Browser scrapen?

Suchen Sie im DevTools-Register „Netzwerk“ die Anfrage, die die Seite für ihre Daten stellt, kopieren Sie deren URL und Parameter und rufen Sie sie selbst mit `fetch()` auf. Sie erhalten JSON ohne HTML-Parsing und ohne, dass ein Browser ausgeführt werden muss. Behalten Sie dasselbe Ratenlimit und denselben User-Agent bei und rufen Sie nur Endpunkte auf, die die Seite selbst für öffentliche Daten nutzt.

Die Schritte sind auf jeder Website gleich:

  1. Öffne die DevTools, wähle den Reiter „Netzwerk“ aus und filtere nach „Fetch/XHR“.
  2. Lade die Seite neu oder klicke auf die Schaltfläche, die Registerkarte oder den Link „Mehr laden“, über den die Daten abgerufen werden.
  3. Klicken Sie auf jede Anfrage und überprüfen Sie die Registerkarte „Antwort“, bis Sie diejenige finden, die Ihre Datensätze enthält.
  4. Notieren Sie sich die URL sowie die Abfrageparameter, die sich ändern (häufig page, offsetoder cursor) sowie alle Felder, die Ihnen anzeigen, wann Sie aufhören müssen, wie z. B. has_next oder ein leeres Array.
  5. Erstellen Sie die URL in Node.js neu mit URLSearchParams und rufe sie in einer Schleife ab.

Ein paginierter JSON-Endpunkt sieht in der Regel so aus. Setze den von dir gefundenen Endpunkt und die Felder ein:

// fetch-json-pages.js: call a paged JSON endpoint you found in the Network tab
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function fetchAllPages(endpoint, { maxPages = 50, delayMs = 1000 } = {}) {
  const items = [];
  for (let page = 1; page <= maxPages; page++) {
    const url = `${endpoint}?${new URLSearchParams({ page })}`;
    const res = await fetch(url, {
      headers: { 'User-Agent': 'node-scraper-tutorial/1.0 (+https://example.com/contact)' },
      signal: AbortSignal.timeout(15_000),
    });
    if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
    const data = await res.json();
    items.push(...data.items);           // the array that holds the records
    if (!data.has_next) break;           // or: if (data.items.length === 0) break;
    await sleep(delayMs);
  }
  return items;
}

Sofern vorhanden, ist dies der schnellste und stabilste Weg: JSON-Felder ändern sich selten, wenn eine Website ihr HTML neu gestaltet. Normalisieren Sie die Daten während der Verarbeitung, genau wie es der Cheerio-Parser tut: Kürzen Sie Zeichenketten, konvertieren Sie Zahlen und wandeln Sie fehlende Schlüssel in null oder false umwandeln.

Wissen Sie auch, wann Sie aufhören müssen. Ein Endpunkt, der eine Anmeldung, ein Session-Token oder signierte Parameter erfordert, ist keine öffentliche Datenquelle, und das Umgehen dieser Prüfungen ist kein Scraping mehr. Behandeln Sie es als Stoppschild, nicht als Rätsel.

Wie scrapt man mit Playwright JavaScript-gerenderte Seiten?

Starte Chromium mit Playwright, öffne die Seite und führe die Aktionen aus, die ein Nutzer ausführen würde, z. B. auf einen Link klicken. Warte auf die Daten, anstatt in einen Ruhezustand zu wechseln: waitForURL() erfasst die durch einen Klick ausgelöste Navigation, und die waitFor()-Methode eines Locators wartet, bis Zeilen vorhanden sind. Lies dann die Zeilen auf der Seite mit evaluateAll() aus und schließe den Browser in einem finally-Block.

Verwende einen Browser, wenn die Daten erst nach Klicks, Scrollen, Eingaben oder anderen skriptgesteuerten Schritten erscheinen. Dieses Skript durchsucht books.toscrape.com wie ein Leser: Es öffnet die Startseite, klickt auf die Kategorie „Mystery“, liest jede Karte und klickt auf „Weiter“, bis die Kategorie erschöpft ist.

// playwright-books.js: open a category like a user, read every page of results
import { chromium } from 'playwright';

const browser = await chromium.launch();               // headless by default
try {
  const page = await browser.newPage({ userAgent: 'node-scraper-tutorial/1.0 (+https://example.com/contact)' });
  await page.route('**/*.{jpg,jpeg,png}', (route) => route.abort());   // skip images you won't use
  await page.goto('https://books.toscrape.com/');

  await page.getByRole('link', { name: 'Mystery', exact: true }).click();
  await page.waitForURL('**/category/books/mystery_3/**');

  const books = [];
  for (;;) {
    const cards = page.locator('article.product_pod');
    await cards.first().waitFor();                     // wait for the data, not a fixed sleep
    books.push(...await cards.evaluateAll((els) => els.map((el) => ({
      title: el.querySelector('h3 a').getAttribute('title'),
      price: Number(el.querySelector('.price_color').textContent.replace(/[^0-9.]/g, '')),
      url: el.querySelector('h3 a').href,               // the browser resolves it for you
    }))));

    const next = page.locator('li.next a');
    if (await next.count() === 0) break;
    const current = page.url();
    await next.click();
    await page.waitForURL((u) => u.href !== current);  // the click navigates to the next page
    await page.waitForTimeout(1000);                   // politeness delay between pages
  }
  console.log(books.length, 'mystery books; last page:', page.url());
  console.log(books[0]);
} finally {
  await browser.close();
}

Ausgabe:

32 mystery books; last page: https://books.toscrape.com/catalogue/category/books/mystery_3/page-2.html
{
  title: 'Sharp Objects',
  price: 47.82,
  url: 'https://books.toscrape.com/catalogue/sharp-objects_997/index.html'
}

Einige Entscheidungen sind hier auf jeder Website von Bedeutung. getByRole('link', { name: 'Mystery', exact: true }) findet den Link so, wie ihn ein Benutzer sieht, sodass er auch bei Änderungen des Klassennamens erhalten bleibt. waitForURL() „after each click“ stellt sicher, dass die neue Seite gelesen wird, nicht die alte. cards.first().waitFor() wartet, bis Daten vorhanden sind – das ist besser als eine feste Wartezeit, die an einem langsamen Tag zu kurz ist oder an einem schnellen Tag Zeitverschwendung darstellt. Das automatische Warten von Playwright überprüft zudem, ob ein Element sichtbar und stabil ist, bevor es angeklickt wird.

Innerhalb von evaluateAll()wird der Code auf der Seite ausgeführt, sodass a.href bereits absolut ist. Das Blockieren von Bildern mit page.route() spart Bandbreite für Sie und die Website. Die einzige verbleibende feste Wartezeit ist eine bewusste Höflichkeitsverzögerung, keine Schätzung der Ladezeit.

Wenn ein Klick eine Datenanfrage statt einer Navigation auslöst, umschließe den Klick und page.waitForResponse() in einen Promise.all() , damit die Antwort nicht eintreffen kann, bevor du mit dem Abhören beginnst. Informationen zu Proxys, unendlichem Scrollen und dem Abfangen von Anfragen findest du in unserem ausführlichen Playwright-Leitfaden.

Wie sieht derselbe Scraper in Puppeteer aus?

Puppeteer deckt denselben Ablauf mit leicht abweichenden Aufrufen ab: page.click() in Kombination mit page.waitForNavigation(), dann page.waitForSelector() und page.$$eval() um die Karten auszulesen. Puppeteer 25 benötigt Node.js 22.12 oder höher.

// puppeteer-books.js: the same category in Puppeteer
import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
try {
  const page = await browser.newPage();
  await page.setUserAgent('node-scraper-tutorial/1.0 (+https://example.com/contact)');
  await page.goto('https://books.toscrape.com/');

  await Promise.all([
    page.waitForNavigation(),
    page.click('a[href*="category/books/mystery_3"]'),
  ]);
  await page.waitForSelector('article.product_pod');

  const books = await page.$$eval('article.product_pod h3 a', (links) => links.map((a) => ({
    title: a.getAttribute('title'),
    url: a.href,
  })));
  console.log(books.length, 'books on page 1;', 'first:', books[0].title);
} finally {
  await browser.close();
}

Ausgabe:

20 books on page 1; first: Sharp Objects

Beachten Sie den Promise.all() um den Klick herum: Warten Sie zunächst auf die Navigation, bevor Sie klicken, da eine schnell ladende Seite möglicherweise bereits vollständig geladen ist, bevor Puppeteer mit dem Abhören beginnt. Screenshots, PDFs und weitere Puppeteer-Muster finden Sie in unserem Leitfaden zu Puppeteer und Node.js.

Sollten Sie Playwright oder Puppeteer für das Web-Scraping verwenden?

Verwende Playwright für neue Scraper: Es wartet automatisch auf Elemente, steuert Chromium, Firefox und WebKit über eine einzige API und kommt gut mit mehreren isolierten Sitzungen zurecht. Verwende Puppeteer, wenn dein Team bereits über Puppeteer-Code verfügt oder Chrome-spezifische Tools benötigt. Beim Scraping rendern beide die gleichen Seiten, wähle also nach der Vertrautheit mit der API und nicht nach Geschwindigkeitsangaben.


Playwright

Puppeteer

Browser

Chromium, Firefox, WebKit

Chrome, Firefox

Warten

Locators warten automatisch, bis Elemente bereit sind

Explizit waitForSelector() und Ähnliches

Isolierte Sitzungen

Browserkontexte, integriert

Browserkontexte, integriert

Datenanfrage abfangen

page.waitForResponse()

page.waitForResponse()

Sprachen

JavaScript/TypeScript, Python, Java, .NET

JavaScript/TypeScript

Aktuelle Version auf npm (Okt. 2026)

1.64.1

25.16.0

Wählen Sie diese Version, wenn

neue Projekte, browserübergreifende Tests

Bestehender Puppeteer-Code, Arbeit mit dem Chrome DevTools-Protokoll

Beide Projekte sind Open Source und werden aktiv gepflegt; beide laden einen passenden Browser für Sie herunter. Der praktische Unterschied zeigt sich im täglichen Code: Die Locators von Playwright warten und versuchen es selbstständig erneut, sodass Skripte weniger explizite Wartezeiten benötigen. Wenn Sie Puppeteer bereits in der Produktion einsetzen, gibt es keinen Grund, es neu zu schreiben.

Wie kann man gesperrte Seiten mit einer Scraper-API aus Node.js scrapen?

Behalte deinen Parser bei und ändere nur den Abruf. Sende die Ziel-URL an die Scraper-API von WebScrapingAPI mit deinem Schlüssel aus einer Umgebungsvariablen, füge `render_js=1` hinzu, wenn die Seite JavaScript benötigt, und füge `country` für standortspezifische Inhalte hinzu. Du erhältst den HTML-Code der Seite zurück und übergibst ihn an dieselbe Cheerio-Funktion, die du bereits geschrieben hast.

Für eine Übungswebsite brauchst du das nicht. Sie benötigen es, wenn ein echtes Ziel mit 403-Fehlern oder Challenge-Seiten antwortet, die sich durch Wiederholungsversuche nicht beheben lassen, wenn sich Inhalte je nach Land ändern oder wenn Sie lieber keine ganze Flotte von Browsern betreiben möchten, um Seiten in großem Umfang zu rendern. Versuchen Sie zunächst andere Wege, um Blockierungen zu reduzieren, wenn Sie nur gelegentlich Fehler feststellen.

Die Scraper-API nimmt eine URL entgegen und gibt die Seite zurück, während die WebScrapingAPI sich um Proxys, Wiederholungsversuche und optionales JavaScript-Rendering kümmert. wsaFetch() ist ein direkt einsetzbares Pendant zu fetchHtml():

// wsa-fetch.js: same job as fetchHtml(), but WebScrapingAPI's Scraper API does the fetching
const ENDPOINT = 'https://api.webscrapingapi.com/v2';
const RETRY = new Set([429, 500, 503]);          // documented as "retry later"
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export function buildWsaUrl(url, { renderJs = false, country } = {}) {
  const apiKey = process.env.WSA_API_KEY;
  if (!apiKey) throw new Error('Set WSA_API_KEY in your environment first.');
  const params = new URLSearchParams({ api_key: apiKey, url });   // encodes the target URL
  if (renderJs) params.set('render_js', '1');
  if (country) params.set('country', country);                     // two-letter code, e.g. "us"
  return `${ENDPOINT}?${params}`;
}

export async function wsaFetch(url, { renderJs = false, country, retries = 2 } = {}) {
  for (let attempt = 0; ; attempt++) {
    const res = await fetch(buildWsaUrl(url, { renderJs, country }), {
      signal: AbortSignal.timeout(130_000),   // the API's own timeout tops out at 120 s
    });
    if (res.ok) return res.text();
    if (res.status === 422 && !renderJs) {    // scrape not completed: try once with rendering
      renderJs = true;
      continue;
    }
    if (!RETRY.has(res.status) || attempt >= retries) {
      throw new Error(`WebScrapingAPI HTTP ${res.status}: ${await res.text()}`);
    }
    await sleep(2000 * 2 ** attempt);
  }
}

Der Schlüssel stammt von process.env.WSA_API_KEY und taucht niemals im Code auf. URLSearchParams kodiert die Ziel-URL, was wichtig ist: Wenn eine Ziel-URL einen eigenen Abfrage-String enthält, würde ein unkodiertes ? oder & als API-Parameter interpretiert. Das Client-Timeout liegt knapp über dem 120-Sekunden-Maximum der API, und nur die Status, die die API als vorübergehend dokumentiert, werden erneut versucht. JavaScript-Rendering und Geotargeting kosten keine zusätzlichen Credits, aber das Rendering ist langsamer; schalte es daher nur ein, wenn deine Daten im HTML fehlen.

Tauschen Sie die Abrufebene aus und behalten Sie parseBooks() genau so, wie es war:

// crawl-books-wsa.js: swap the fetch layer, keep parseBooks() unchanged
import { wsaFetch, buildWsaUrl } from './wsa-fetch.js';
import { parseBooks } from './parse-books.js';

const url = 'https://books.toscrape.com/catalogue/page-1.html';
const opts = { country: 'us' };                    // add renderJs: true only if the HTML lacks the data

if (process.argv.includes('--dry-run')) {
  const redact = (u) => u.replace(/api_key=[^&]+/, 'api_key=REDACTED');
  console.log(redact(buildWsaUrl(url, opts)));
  console.log(redact(buildWsaUrl(url, { ...opts, renderJs: true })));
} else {
  const { books, nextUrl } = parseBooks(await wsaFetch(url, opts), url);
  console.log(books.length, 'books; first:', books[0]?.title, '; next:', nextUrl);
}

Fügen Sie den Schlüssel in eine .env Datei ein, die WSA_API_KEY=your_key_here, füge .env zu .gitignoreund lade sie mit dem in Node integrierten --env-file Flag laden, sodass Sie das dotenv-Paket nicht benötigen:

node --env-file=.env crawl-books-wsa.js --dry-run
node --env-file=.env crawl-books-wsa.js

Der Testlauf gibt die Anfrage-URLs mit geschwärztem Schlüssel aus, sodass du die Kodierung sehen kannst:

https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fbooks.toscrape.com%2Fcatalogue%2Fpage-1.html&country=us
https://api.webscrapingapi.com/v2?api_key=REDACTED&url=https%3A%2F%2Fbooks.toscrape.com%2Fcatalogue%2Fpage-1.html&render_js=1&country=us

Der eigentliche Lauf übergibt den zurückgegebenen HTML-Code an denselben Parser:

20 books; first: A Light in the Attic ; next: https://books.toscrape.com/catalogue/page-2.html

Fehler werden explizit angezeigt. Ohne die Umgebungsvariable bricht das Skript ab, Error: Set WSA_API_KEY in your environment first. bevor etwas gesendet wird, und ein falscher Schlüssel wird als WebScrapingAPI HTTP 401: {"error":"Invalid API key"} statt eines leeren Ergebnisses zurückgegeben. Alle Parameter und Fehlercodes findest du in unserer vollständigen Anleitung zur Scraper-API. Seiten, die Klicks oder Eingaben erfordern, eignen sich besser für einen gehosteten Browser als für einen „Fetch“-Aufruf, worauf im nächsten Abschnitt eingegangen wird.

Welche JavaScript-Scraping-Methode solltest du verwenden?

Verwenden Sie „fetch“ und Cheerio, wenn sich die Daten im HTML befinden. Rufen Sie den JSON-Endpunkt auf, wenn JavaScript Daten von einem solchen lädt. Verwenden Sie Playwright, wenn Sie auf der Seite klicken, scrollen oder warten müssen. Verwenden Sie eine Scraper-API, wenn Blöcke, der Standort oder das Rendern in großem Umfang das lokale Abrufen unzuverlässig machen. Die meisten Projekte kombinieren zwei dieser Methoden.

Situation

Verwendung

Warum

Daten befinden sich im Quelltext

fetch + Cheerio

Am schnellsten, mit den wenigsten beweglichen Teilen

Viele Seiten

fetch + Cheerio mit robots.txt, Verzögerung, Wiederholungsversuchen und Duplikatsbereinigung

Höflich und neu startbar

JavaScript lädt Daten über einen XHR-Aufruf, den du

fetch am JSON-Endpunkt

Kein Parsen, kein Browser

Die Daten liegen als JSON in einem <script>

Cheerio + JSON.parse

Kein Browser

Klicks, Scrollen oder Warten auf der Seite

Playwright (oder Puppeteer)

Echter Browser, echte Ereignisse

403-Fehler, Challenge-Seiten, länderspezifische Inhalte oder Rendering in großem Umfang

Scraper-API von fetch

Verwaltete Proxys, Wiederholungsversuche und Rendering; Parser unverändert

Gehostete Browsersitzungen mit Aktionen

Browser-API

Sitzungen, ohne Chrome selbst ausführen zu müssen

Führen Sie für jede neue Website nacheinander folgende Überprüfungen durch:

  1. Sind die Daten im Quelltext zu sehen? Verwenden Sie fetch und Cheerio.
  2. Werden die Daten über eine Fetch-/XHR-Anfrage übermittelt? Rufe diese Anfrage auf.
  3. Benötigst du Klicks, Scrollen oder Wartezeiten? Verwende Playwright.
  4. Wirst du blockiert oder ist der Inhalt standortspezifisch? Leite den Abruf über die Scraper-API weiter.
  5. Benötigst du gehostete Browsersitzungen, die klicken und tippen? Verwende die Browser-API.

Wie testet man einen Node.js-Scraper, damit er nicht unbemerkt ausfällt?

Speichern Sie eine Kopie jedes Seitentyps als HTML-Datei und testen Sie Ihren Parser damit mithilfe des in Node integrierten Test-Runners. Überprüfen Sie die Zeilenanzahl, die Typen der Schlüsselfelder und den Link zur nächsten Seite. Wenn die Website ihr Layout ändert, schlägt ein Test laut fehl, anstatt dass Ihr Scraper stillschweigend leere oder falsche Daten speichert.

Scraper stürzen selten ab, wenn sich eine Website ändert. Sie laufen einfach weiter und speichern leere Zeichenfolgen, Nullen oder gar nichts. Fixture-Tests erkennen das, bevor fehlerhafte Daten in Ihre Datenbank gelangen. Speichern Sie die letzte Katalogseite und eine Kategorieseite neben der ersten Seite, die Sie zuvor gespeichert haben:

curl -o fixtures/books-page-50.html "https://books.toscrape.com/catalogue/page-50.html"
sleep 1
curl -o fixtures/mystery-page-1.html "https://books.toscrape.com/catalogue/category/books/mystery_3/index.html"

Schreiben Sie dann die Tests mit node:test und node:assert/strict. Es sind keine zusätzlichen Pakete erforderlich:

// parse-books.test.js: run with `node --test`; uses saved pages, no network
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import { parseBooks } from './parse-books.js';

const BASE = 'https://books.toscrape.com/catalogue/';
const load = (name) => readFile(`fixtures/${name}`, 'utf8');

test('parses 20 typed records and the next link', async () => {
  const { books, nextUrl } = parseBooks(await load('books-page-1.html'), `${BASE}page-1.html`);
  assert.equal(books.length, 20);
  for (const b of books) {
    assert.ok(b.title.length > 0);
    assert.ok(Number.isFinite(b.price) && b.price > 0, b.title);
    assert.ok(b.rating >= 1 && b.rating <= 5, b.title);
  }
  assert.equal(nextUrl, `${BASE}page-2.html`);
});

test('resolves ../../../ links on category pages', async () => {
  const url = `${BASE}category/books/mystery_3/index.html`;
  const { books } = parseBooks(await load('mystery-page-1.html'), url);
  assert.equal(books[0].url, `${BASE}sharp-objects_997/index.html`);
});

test('the last page has no next link', async () => {
  const { books, nextUrl } = parseBooks(await load('books-page-50.html'), `${BASE}page-50.html`);
  assert.equal(books.length, 20);
  assert.equal(nextUrl, null);
});

Führen Sie node --test:

✔ parses 20 typed records and the next link
✔ resolves ../../../ links on category pages
✔ the last page has no next link
ℹ tests 3
ℹ pass 3
ℹ fail 0

Der zweite Test schützt vor der Falle mit den relativen Links: Kategorieseiten verlinken Bücher als ../../../sharp-objects_997/index.html, und ein Parser, der dies falsch verarbeitet, würde immer noch 20 Datensätze zurückgeben – nur mit fehlerhaften URLs. Speichern Sie Ihre Fixtures regelmäßig neu und vergleichen Sie die geparsten Ausgaben, damit Sie Layoutänderungen bemerken, bevor Ihre Nutzer sie bemerken. Der in Node integrierte Test-Runner unterstützt außerdem den Watch-Modus, Coverage und Snapshots.

Ist JavaScript oder Python besser für das Web-Scraping geeignet?

Beides funktioniert gut. Entscheiden Sie sich für JavaScript, wenn Ihr Team bereits damit arbeitet, wenn Sie Browser automatisieren möchten oder wenn der Scraper in einem Node.js-Dienst läuft. Wählen Sie Python, wenn die Daten in pandas, Notebooks oder Machine Learning einfließen oder wenn Sie das Crawling-Framework von Scrapy nutzen möchten. Die Abwehrmaßnahmen der Website sind weitaus wichtiger als die von Ihnen gewählte Sprache.

Die Bausteine entsprechen fast eins zu eins. Native fetch entspricht den HTTP-Clients von Python, Cheerio übernimmt die Rolle eines schnellen HTML-Parsers, und Playwright ist in beiden Sprachen mit nahezu derselben API verfügbar. Der Vorteil von JavaScript liegt in der Browser-Automatisierung und einer einheitlichen Sprache von den Skripten der Seite bis hin zu Ihrem Backend. Der Vorteil von Python liegt im nachgelagerten Analyse-Stack und einem ausgereiften Crawling-Framework für sehr große Aufgaben. Wenn dein Team mit Python arbeitet, lies unseren Leitfaden zum Web-Scraping mit Python. Die Empfehlungen in diesem Leitfaden gelten unverändert.

Wie führt man verantwortungsbewusstes Web-Scraping mit JavaScript durch?

Lies dir vor dem Crawling die Nutzungsbedingungen und die robots.txt der Website durch, halte die Anfragefrequenz niedrig, identifiziere deinen Scraper mit einem ehrlichen User-Agent und sammle nur die Felder, die du benötigst. Vermeide personenbezogene Daten, es sei denn, du hast eine rechtmäßige Grundlage dafür, scrape niemals ohne Erlaubnis hinter einem Login und nutze die offizielle API der Website, sofern eine vorhanden ist.

Das meiste davon ist bereits in Ihrem Code enthalten. robots.js überprüft die Regeln vor dem Abruf der ersten Seite. Die Verzögerung von einer Sekunde und die Begrenzung auf zwei Worker sorgen für eine geringe Auslastung. Der User-Agent Header benennt Ihren Scraper und bietet der Website eine Möglichkeit, Sie zu erreichen. Und der Parser behält nur die Felder bei, die Sie benötigen – typisiert und bereinigt –, anstatt ganze Seiten zu speichern.

Der Rest ist eine Ermessensfrage. Öffentliche Seiten sind kein Freifahrtschein: Nutzungsbedingungen, Urheberrecht und Datenschutzgesetze gelten weiterhin, insbesondere in Bezug auf personenbezogene Daten. Lies unsere Grundsätze für verantwortungsvollen Umgang mit Webdaten und unseren Überblick darüber, ob Web-Scraping legal ist, und hole rechtlichen Rat ein, bevor du für ein kommerzielles Projekt Daten auslesest.

Häufig gestellte Fragen

Eignet sich Node.js für das Web-Scraping?

Ja. Node.js verarbeitet viele Netzwerkanfragen gleichzeitig ohne Threads, verfügt über eine integrierte Fetch-Funktion und unterstützt die führenden Browser-Automatisierungstools Playwright und Puppeteer. Cheerio parst HTML schnell mit vertrauten CSS-Selektoren. Es eignet sich besonders gut, wenn Ihr Team bereits JavaScript schreibt oder der Scraper innerhalb eines Node.js-Dienstes läuft.

Warum gibt Cheerio ein leeres Array zurück?

Meistens, weil die Daten nicht in dem HTML enthalten sind, das Ihre Anfrage erhalten hat. JavaScript fügt sie im Browser erst nach dem Laden der Seite hinzu, sodass Cheerio sie nie zu Gesicht bekommt. Überprüfen Sie den Quellcode in Ihrem Browser: Wenn die Daten dort fehlen, suchen Sie die JSON-Anfrage auf der Registerkarte „Netzwerk“ oder rendern Sie die Seite mit Playwright.

Was ist der Unterschied zwischen Cheerio und Playwright?

Cheerio analysiert HTML, das du bereits abgerufen hast. Es ist schnell und schlank, kann aber kein JavaScript ausführen und nichts anklicken. Playwright steuert einen echten Browser an, sieht die Seite also nach der Ausführung von Skripten und kann klicken, scrollen und warten. Verwende standardmäßig Cheerio und greife nur dann auf Playwright zurück, wenn die Seite einen Browser benötigt.

Kann JavaScript dynamische Websites auslesen?

Ja. Bei Seiten, die Daten mit JavaScript laden, suchen Sie zunächst nach der JSON-Anfrage, die die Seite stellt, und rufen Sie diese mit `fetch()` auf – das ist schneller und stabiler. Wenn Sie auf der Seite Klicks, Scrollen oder Wartezeiten benötigen, verwenden Sie Playwright oder Puppeteer, um die Seite in einem headless Browser zu laden und die gerenderten Elemente auszulesen.

Wie vermeide ich es, beim Scraping mit Node.js blockiert zu werden?

Verringern Sie die Geschwindigkeit, senden Sie einen seriösen User-Agent, wiederholen Sie Versuche bei 429- und 503-Antworten erst nach Ablauf der „Retry-After“-Verzögerung und speichern Sie Seiten im Cache, damit Sie sie nicht zweimal abrufen. Wenn eine Website weiterhin 403-Fehler oder Challenge-Seiten zurückgibt, leite die Anfragen über eine Scraper-API weiter, die Proxys und das Rendern verwaltet, und behalte deinen Cheerio-Parser unverändert bei.

Brauche ich für das Web-Scraping noch Axios oder node-fetch?

Nein. Node.js 18 und höher enthalten „fetch“, und diese Funktion ist in jeder unterstützten Version stabil, sodass ein neuer Scraper keine HTTP-Bibliothek benötigt. Axios und Got funktionieren weiterhin und bieten zusätzliche Annehmlichkeiten wie Interceptors und integrierte Wiederholungsversuche. Behalte sie bei, wenn dein Projekt sie bereits nutzt. Andernfalls reichen das native „fetch“ sowie ein kleiner Retry-Helper aus.

Wie sollte ich einen API-Schlüssel in einem Node.js-Scraper speichern?

Speichere den Schlüssel in einer Umgebungsvariablen wie „WSA_API_KEY“ und lies ihn mit „process.env“ aus. Für die lokale Arbeit lege ihn in einer „.env“-Datei ab, führe „node --env-file=.env“ aus und füge „.env“ zu „.gitignore“ hinzu. Fügen Sie Schlüssel niemals in Code, in von Ihnen geteilte URLs oder in Frontend-JavaScript ein, wo sie von jedem Besucher gelesen werden könnten.

Kann ich Websites mit TypeScript scrapen?

Ja. Jedes Beispiel in dieser Anleitung funktioniert in TypeScript, da Cheerio, Playwright und Puppeteer ihre eigenen Typdefinitionen mitliefern. Aktuelle Node.js-Versionen können .ts-Dateien direkt ausführen, indem sie die Typen entfernen, oder du kannst einen Runner wie tsx verwenden. Durch die Typisierung deiner Datensatzstrukturen werden außerdem Parser-Fehler erkannt, bevor du fehlerhafte Daten speicherst.

Wie kann ich eine Seite mit unendlichem Bildlauf scrapen?

Öffne die DevTools, scrolle durch die Seite und beobachte im Reiter „Netzwerk“ die Anfrage, die jeden neuen Datensatz lädt. Diese benötigt in der Regel eine Seitenzahl oder eine Cursorposition, sodass du sie mit `fetch()` in einer Schleife aufrufen kannst, bis keine Ergebnisse mehr gemeldet werden. Falls es keine verwertbare Anfrage gibt, scrolle mit Playwright und lies die Zeilen aus.

Die Sprache ändert nichts an der rechtlichen Situation. Das Scrapen öffentlicher Daten ist oft rechtmäßig, hängt jedoch von den Nutzungsbedingungen der Website, der Art der Daten und den lokalen Gesetzen ab, insbesondere bei personenbezogenen Daten und urheberrechtlich geschützten Inhalten. Halten Sie sich an die robots.txt, vermeiden Sie die Erfassung personenbezogener Daten ohne rechtmäßige Grundlage und holen Sie bei kommerziellen Projekten rechtlichen Rat ein.

Behalte deinen Node.js-Parser, delegiere die schwierigen Seiten

Ihr Cheerio-Parser muss nicht geändert werden, wenn eine Website Sie blockiert oder JavaScript benötigt. Leiten Sie Ihren Abruf an die Scraper-API von WebScrapingAPI weiter und fahren Sie mit dem Parsen in Node.js fort. JavaScript-Rendering und Geotargeting kosten keine zusätzlichen Credits, und fehlgeschlagene Anfragen werden nicht in Rechnung gestellt. Vergleichen Sie die Tarife der Scraper-API – beginnen Sie mit einer kostenlosen Testversion für 5.000 Anfragen.

Über den Autor

Robert Sfichi, Full-Stack-Entwickler @ WebScrapingAPI

Robert Sfichi

Full-Stack-Entwickler

Robert Sfichi ist Teammitglied bei WebScrapingAPI, wo er an der Produktentwicklung mitwirkt und dabei hilft, zuverlässige Lösungen zu entwickeln, die die Plattform und ihre Nutzer unterstützen.

Web-Scraping mit AWS Lambda: Leitfaden für Python und Java 2026
Anleitungen

Web-Scraping mit AWS Lambda: Leitfaden für Python und Java 2026

TL;DR: Kurz gesagt: Web-Scraping mit AWS Lambda funktioniert am besten, wenn jeder Aufruf kurz, begrenzt und unabhängig wiederholbar ist. Beginnen Sie mit direktem HTTP, AWS SAM und S3 und fügen Sie erst dann SQS, Container, Browser-Rendering, Proxys oder eine verwaltete Abrufebene hinzu, wenn sich im Rahmen der Arbeitslast herausstellt, dass diese erforderlich sind.

Suciu Dan26 min read
Artikel lesen
So verwenden Sie GoSpider: Crawlen, URLs bereinigen und Daten extrahieren
Anleitungen

So verwenden Sie GoSpider: Crawlen, URLs bereinigen und Daten extrahieren

TL;DR: GoSpider ist ein Befehlszeilen-Crawler zum Auffinden von URLs, kein vollständiger Scraper für strukturierte Daten. Diese Anleitung zur Verwendung von GoSpider zeigt einen begrenzten Crawl, die saubere Verarbeitung der Ausgabe, die Übergabe von Colly an CSV sowie einen Diagnosepfad für 403-Antworten oder Seiten, die eine JavaScript-Darstellung erfordern.

Suciu Dan20 min read
Artikel lesen
Wie man Redfin scrappt: Python-Leitfaden für Immobiliendaten
Anleitungen

Wie man Redfin scrappt: Python-Leitfaden für Immobiliendaten

TL;DR: Redfin stellt versteckte API-Endpunkte zur Verfügung, die strukturiertes JSON für Immobilienangebote zurückgeben, wodurch das fragile HTML-Parsing vollständig übersprungen werden kann. Diese Anleitung führt Sie durch den Aufbau eines Python-Scrapers, der Miet- und Verkaufsdaten extrahiert, nach Standort sucht, neue Angebote über XML-Sitemaps überwacht und saubere Ergebnisse in CSV oder JSON exportiert.

Suciu Dan11 min read
Artikel lesen

Los geht’s

Sind Sie bereit, Ihre Datenerfassung zu erweitern?

Schließen Sie sich den über 2.000 Unternehmen an, die WebScrapingAPI nutzen, um Webdaten im Unternehmensmaßstab ohne zusätzlichen Infrastrukturaufwand zu extrahieren.