Ohne KYC – keine ID, kein Selfie, keine Dokumente. Mit Krypto bezahlen: BTC, USDT, USDC, ETH, SOL, LTC
Sprache: Deutsch
API-Schlüssel erhalten

Docs · Node.js

Webseite in Markdown umwandeln in Node.js

Node.js 18 und später liefern fetch mit, Sie brauchen also gar keine Abhängigkeit. Drei Rezepte: eine Seite lesen, eine Liste mit einem kleinen Concurrency-Pool lesen und einen Crawl-Job verfolgen, bis er fertig ist.

Zuletzt aktualisiert: · 4 Min. Lesezeit

Kurze Antwort

Wie wandle ich eine Webseite in Markdown um in Node.js?

Nutzen Sie das eingebaute fetch von Node.js 18+: Rufen Sie https://webreaderapi.com/api/v1/read?url=… mit Ihrem Schlüssel im Authorization-Header auf und lesen Sie markdown aus der JSON-Antwort. WebReaderAPI liefert den Hauptinhalt der Seite mit Titel, Autor und Datum. Eine Seite kostet 1 Credit, 2 mit Browser, ab 0,07 $/1K Seiten Stand Oktober 2026. Ohne KYC; mit Krypto bezahlen.

Was brauche ich?

Node.js 18 oder später, für das globale fetch, und einen API-Schlüssel in der Umgebungsvariable WEBREADER_API_KEY. Die Beispiele sind ES-Module: Speichern Sie sie mit der Endung .mjs oder setzen Sie "type": "module" in Ihrer package.json, damit Top-Level-await funktioniert.

Die JSDoc-Kommentare beschreiben die Form der Antwort, sodass Editoren wie VS Code Ihnen Autovervollständigung ohne TypeScript-Build-Schritt geben.

read.mjs: eine Seite
/**
 * @typedef {Object} Page
 * @property {string} url
 * @property {string} final_url
 * @property {number} status_code
 * @property {boolean} rendered
 * @property {number} credits_used
 * @property {string} [title]
 * @property {string} [author]
 * @property {string} [published_at]
 * @property {string} [language]
 * @property {string} [markdown]
 * @property {number} word_count
 */

/** @returns {Promise<Page>} */
export async function readPage(url, options = {}) {
  const params = new URLSearchParams({ url, ...options });
  const res = await fetch(`https://webreaderapi.com/api/v1/read?${params}`, {
    headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
    signal: AbortSignal.timeout(75_000),
  });
  const body = await res.json();
  if (!res.ok) throw Object.assign(new Error(body.error.message), { code: body.error.code });
  return body;
}

const page = await readPage('https://example.com/docs/getting-started', { max_chars: '20000' });
console.log(page.title, page.word_count, 'words,', page.credits_used, 'credit(s)');

Wie lese ich eine Liste von URLs, ohne das Limit zu erreichen?

Führen Sie eine feste Anzahl von Workern aus, die URLs aus einer gemeinsamen Warteschlange nehmen. Das ist einfacher als Promise.all über die ganze Liste, das alle Anfragen auf einmal starten und das 429 concurrency_limit erreichen würde. Jedes Konto hat ein Limit dafür, wie viele Seiten es gleichzeitig liest; Ihr Dashboard zeigt es an, und der Support kann es erhöhen.

Der Pool unten legt Fehler neben die Ergebnisse, sodass eine abgelehnte Seite den Lauf nicht stoppt. Ablehnungen wie blocked_by_robots sind endgültig und kostenlos; zählen Sie sie und machen Sie weiter.

pool.mjs: eine Liste von URLs, 8 auf einmal
import { readPage } from './read.mjs';

export async function readAll(urls, workers = 8) {
  const queue = [...urls];
  const results = [];
  async function worker() {
    while (queue.length) {
      const url = queue.shift();
      try {
        const page = await readPage(url, { max_chars: '50000' });
        results.push({ url, page });
      } catch (err) {
        results.push({ url, error: err.code ?? err.name });
      }
    }
  }
  await Promise.all(Array.from({ length: workers }, worker));
  return results;
}

const urls = Array.from({ length: 30 }, (_, i) => `https://example.com/blog/post-${i + 1}`);
for (const r of await readAll(urls)) console.log(r.url, '->', r.error ?? r.page.title);

Wie verfolge ich einen Crawl-Job in Node.js?

Starten Sie den Job mit POST https://webreaderapi.com/api/v1/crawl und lesen Sie dann https://webreaderapi.com/api/v1/jobs/{job_id} in einer Schleife. Übergeben Sie cursor jedes Mal, wenn next_cursor zurückkommt; wenn kein Cursor mehr vorhanden ist und der Status done lautet, ist der Job fertig. Warten Sie zwischen leeren Abfragen und verdoppeln Sie die Wartezeit bis zu 30 Sekunden, da ein Crawl, der die Crawl-delay einer Website respektiert, langsam sein kann.

Die Batch- und Crawl-Seite beschreibt, wie der Crawl seine Seiten wählt und wie limit begrenzt, was er liest.

crawl.mjs: einen Crawl starten und jede Seite sammeln
const headers = {
  Authorization: `Bearer ${process.env.WEBREADER_API_KEY}`,
  'Content-Type': 'application/json',
};
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const start = await fetch('https://webreaderapi.com/api/v1/crawl', {
  method: 'POST',
  headers,
  body: JSON.stringify({ url: 'https://docs.example.com/', limit: 300, include_paths: ['/docs/*'] }),
});
const { job_id } = await start.json();

const pages = [];
let cursor = '';
let wait = 2000;
for (;;) {
  const url = `https://webreaderapi.com/api/v1/jobs/${job_id}${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`;
  const job = await (await fetch(url, { headers })).json();
  pages.push(...job.results.filter((r) => !r.error));
  if (job.next_cursor) {
    cursor = job.next_cursor;
    wait = 2000;
    continue;
  }
  if (job.status === 'done') break;
  await sleep(wait);
  wait = Math.min(wait * 2, 30000);
}
console.log(pages.length, 'pages read, job', job_id);

Wie übergebe ich das Ergebnis an ein Modell?

Senden Sie das Markdown, nicht das ganze JSON. Das Feld markdown ist das, was ein Modell lesen sollte; die Metadaten bewahren Sie besser für Quellenangaben auf. Stellen Sie Titel und final_url voran, damit das Modell seine Quelle nennen kann, und halten Sie max_chars in einer Größe, die der Kontext Ihres Modells aufnehmen kann, etwa 20.000 Zeichen pro Seite.

Die OpenAI-Function-Calling-Seite zeigt die vollständige Tool-Schleife in Python; dieselbe readPage-Funktion oben kann als Tool-Body in einem Node.js-Agenten dienen.

Node.js: häufige Fragen

Funktioniert das in Deno, Bun oder im Browser?

Deno und Bun unterstützen dasselbe fetch und ES-Module. Rufen Sie die API nicht aus einer Browser-Seite auf: Der Schlüssel wäre für jeden Besucher sichtbar. Rufen Sie sie stattdessen von Ihrem Server aus auf.

Gibt es ein npm-Paket?

Nein. Die Funktionen auf dieser Seite sind die gesamte Integration. WebReaderAPI ist reines HTTPS und JSON, sodass Sie die Kontrolle über Wiederholungen, Timeouts und Logging behalten.

Wie gehe ich mit 429 concurrency_limit um?

Verringern Sie die Anzahl der Worker oder wiederholen Sie nach einer kurzen Wartezeit, die sich jedes Mal verdoppelt. Ein 429 kostet nichts, und die Fehlerseite enthält eine fertige Backoff-Funktion.

Was kostet das Lesen von 10.000 Seiten?

Etwa 10.000 Credits für einfache Seiten, mehr, wenn einige einen Browser benötigen. 10.000 Seiten kosten 3,75 $; Prepaid-Credits verfallen nie: Ungenutzte Seiten bleiben auf Ihrem Konto, bis Sie sie verwenden.

Ab 0,07 $/1K Seiten · ohne KYC

API-Schlüssel erhalten