Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto: BTC, USDT, USDC, ETH, SOL, LTC
Taal: Nederlands
Vraag een API-sleutel aan

Docs · Node.js

Webpagina naar Markdown in Node.js

Node.js 18 en later leveren fetch mee, dus je hebt helemaal geen dependency nodig. Drie recepten: één pagina lezen, een lijst lezen met een kleine concurrency-pool, en een crawl-job volgen tot die klaar is.

Laatst bijgewerkt: · 4 min leestijd

Kort antwoord

Hoe converteer ik een webpagina naar Markdown in Node.js?

Gebruik de ingebouwde fetch van Node.js 18+: roep https://webreaderapi.com/api/v1/read?url=… aan met je sleutel in de Authorization-header en lees markdown uit het JSON-antwoord. WebReaderAPI geeft de hoofdinhoud van de pagina terug met de titel, auteur en datum. Eén pagina kost 1 credit, 2 met een browser, vanaf US$ 0,07/1K pagina's per oktober 2026. Zonder KYC; betalen met crypto.

Wat heb ik nodig?

Node.js 18 of later, voor de globale fetch, en een API-sleutel in de omgevingsvariabele WEBREADER_API_KEY. De voorbeelden zijn ES-modules: sla ze op met de extensie .mjs, of zet "type": "module" in je package.json, zodat top-level await werkt.

De JSDoc-comments beschrijven de vorm van het antwoord, zodat editors zoals VS Code je aanvulling geven zonder een TypeScript-buildstap.

read.mjs: één pagina
/**
 * @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)');

Hoe lees ik een lijst met URL's zonder tegen de limiet aan te lopen?

Laat een vast aantal workers URL's uit een gedeelde queue halen. Dat is eenvoudiger dan Promise.all over de hele lijst, wat elk verzoek tegelijk zou starten en tegen 429 concurrency_limit aan zou lopen. Elk account heeft een limiet voor het aantal pagina's dat het tegelijk leest; je dashboard toont die, en support kan hem verhogen.

De pool hieronder bewaart fouten naast de resultaten, zodat één geweigerde pagina de run niet stopt. Weigeringen zoals blocked_by_robots zijn definitief en gratis; tel ze en ga verder.

pool.mjs: een lijst met URL's, 8 tegelijk
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);

Hoe volg ik een crawl-job in Node.js?

Start de job met POST https://webreaderapi.com/api/v1/crawl en lees dan https://webreaderapi.com/api/v1/jobs/{job_id} in een loop. Geef cursor mee telkens wanneer next_cursor terugkomt; als er geen cursor is en de status done is, is de job klaar. Wacht tussen lege polls en verdubbel de wachttijd tot 30 seconden, want een crawl die de Crawl-delay van een site respecteert kan traag zijn.

De batch- en crawl-pagina beschrijft hoe de crawl zijn pagina's kiest en hoe limit begrenst wat hij leest.

crawl.mjs: start een crawl en verzamel elke pagina
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);

Hoe geef ik het resultaat door aan een model?

Stuur de Markdown, niet de hele JSON. Het veld markdown is wat een model zou moeten lezen; de metadata kun je beter bewaren voor citaties. Zet de titel en final_url ervoor, zodat het model zijn bron kan noemen, en houd max_chars op een grootte die de context van je model aankan, zoals 20.000 tekens per pagina.

De OpenAI function-calling-pagina laat de volledige tool-loop in Python zien; dezelfde readPage-functie hierboven kan dienen als de tool-body in een Node.js-agent.

Node.js: veelgestelde vragen

Werkt dit in Deno, Bun of de browser?

Deno en Bun ondersteunen dezelfde fetch en ES-modules. Roep de API niet aan vanuit een browserpagina: de sleutel zou zichtbaar zijn voor elke bezoeker. Roep hem aan vanuit je server.

Is er een npm-package?

Nee. De functies op deze pagina zijn de hele integratie. WebReaderAPI is gewoon HTTPS en JSON, dus je houdt zelf controle over retries, timeouts en logging.

Hoe ga ik om met 429 concurrency_limit?

Verlaag het aantal workers, of probeer het opnieuw na een korte wachttijd die elke keer verdubbelt. Een 429 kost niets, en de errors-pagina heeft een kant-en-klare backoff-functie.

Wat kost het lezen van 10.000 pagina's?

Ongeveer 10.000 credits voor gewone pagina's, meer als sommige een browser nodig hebben. 10.000 pagina's kosten US$ 3,75; Prepaid credits verlopen nooit: ongebruikte pagina's blijven op je account staan tot je ze gebruikt.

Vanaf US$ 0,07/1K pagina's · zonder KYC

Vraag een API-sleutel aan