# MCP-server voor webpagina's lezen voor Claude, Cursor en andere MCP-clients

> WebReaderAPI: MCP-server om webpagina's te lezen voor Claude Desktop en Cursor. Een Python-tool van 40 regels geeft schone Markdown, betalen met crypto.

- URL: https://webreaderapi.com/nl/docs/mcp/
- Laatst bijgewerkt: 2026-10-22
- Uitgever: WebReaderAPI (https://webreaderapi.com)

Geef elke MCP-client een `read_url`-tool die een link omzet in schone Markdown. De server is één kort Python-bestand dat je op je eigen machine draait; je API-sleutel blijft in de omgeving ervan.

**Kort antwoord — Hoe voeg ik met MCP een webpagina-lezer toe aan Claude Desktop of Cursor?**

Draai een kleine MCP-server die een `read_url`-tool aanbiedt die **WebReaderAPI** aanroept, en registreer hem daarna in de MCP-instellingen van je client met je sleutel in `env`. Het model kan dan elke openbare pagina als schone Markdown lezen. Elke gelezen pagina kost 1 credit, 2 met een browser, vanaf US$ 0,07/1K pagina's per oktober 2026. Zonder KYC; betalen met crypto.

## De MCP-server in één oogopslag

| Kenmerk | Waarde |
| --- | --- |
| Taal | Python 3.10+, met de packages `mcp` en `httpx` |
| Transport | stdio: de client start de server als een lokaal proces |
| Tool | `read_url(url, max_chars)` → titel, bron-URL, dan de Markdown van de pagina |
| Waarom niet web_fetch | Claude Code en OpenClaw leveren al een ingebouwde tool met die naam |
| Sleutel | Uit `WEBREADER_API_KEY` gelezen in de omgeving van de server |
| Facturering | 1 credit = 1 pagina lezen zonder browser; 2 credits wanneer de pagina een browser nodig heeft om JavaScript te renderen. Een verzoek dat mislukt, of dat de robots.txt van een site weigert, wordt niet in rekening gebracht |

## Waarom een read_url-tool en niet web_fetch?

Omdat twee tools met dezelfde naam zowel de client als het model in de war brengen. Claude Code en OpenClaw bevatten al een tool met de naam `web_fetch`. Een eigen naam, `read_url`, en een duidelijke beschrijving laten het model de onze kiezen wanneer het de hoofdinhoud van een pagina nodig heeft, inclusief JavaScript-pagina's en PDF's.

De tool geeft tekst terug, geen JSON. Modellen gaan beter om met een korte header en Markdown dan met geneste velden, en de header houdt de bron-URL in zicht zodat het antwoord ernaar kan verwijzen.

*webreader_mcp.py*

```python
import os

import httpx
from mcp.server.fastmcp import FastMCP

API = "https://webreaderapi.com/api/v1/read"
KEY = os.environ["WEBREADER_API_KEY"]
mcp = FastMCP("webreaderapi")


@mcp.tool()
def read_url(url: str, max_chars: int = 20000) -> str:
    """Read a public web page and return its main content as Markdown.

    Use it when the user gives a link or when a page must be read to answer.
    max_chars caps the length of the returned text (1,000 to 500,000).
    """
    params = {"url": url, "max_chars": max(1000, min(int(max_chars), 500000))}
    try:
        resp = httpx.get(API, params=params, headers={"Authorization": "Bearer " + KEY}, timeout=75)
    except httpx.HTTPError as exc:
        return "Network error while reading the page: " + str(exc)
    body = resp.json()
    if resp.status_code != 200:
        err = body.get("error", {})
        return "Could not read the page: " + err.get("code", str(resp.status_code)) + ". " + err.get("message", "")
    title = body.get("title") or url
    return "# " + title + "\nSource: " + body.get("final_url", url) + "\n\n" + body.get("markdown", "")


if __name__ == "__main__":
    mcp.run()

```

## Hoe installeer en test ik de server?

Maak een virtuele omgeving, installeer `mcp` en `httpx`, en sla het bestand hierboven op. Het package `mcp` is de officiële Python-SDK van het Model Context Protocol; `FastMCP` maakt van een getypeerde Python-functie een tool, met de docstring als beschrijving.

Voordat je hem aan een client koppelt, draai je het bestand één keer vanuit een terminal met je sleutel ingesteld. Het wacht stil op een client via stdin, wat betekent dat het correct is gestart; stop het met Ctrl+C.

*Installeren*

```bash
python -m venv .venv
. .venv/bin/activate
pip install "mcp[cli]" httpx
WEBREADER_API_KEY="your-key" python webreader_mcp.py
```

## Hoe registreer ik hem in Claude Desktop?

Open de developer-instellingen van Claude Desktop, bewerk `claude_desktop_config.json` en voeg een entry toe onder `mcpServers`. Gebruik absolute paden: de Python van je virtuele omgeving en het serverbestand. Zet de sleutel in `env`, zodat die nooit in de argumenten van de tool of in het gesprek verschijnt. Herstart Claude Desktop en `read_url` verschijnt in de tools-lijst.

Cursor leest dezelfde `mcpServers`-structuur uit zijn eigen MCP-configuratiebestand, en Claude Code kan hetzelfde commando registreren met zijn `claude mcp add`-commando. Voor OpenClaw, zie de [OpenClaw-pagina](https://webreaderapi.com/nl/docs/openclaw/).

*claude_desktop_config.json*

```json
{
  "mcpServers": {
    "webreaderapi": {
      "command": "/home/you/webreader/.venv/bin/python",
      "args": ["/home/you/webreader/webreader_mcp.py"],
      "env": { "WEBREADER_API_KEY": "your-key" }
    }
  }
}
```

## Hoe houd ik pagina's binnen de context van het model?

Verlaag `max_chars`. De standaardwaarde van 20.000 tekens is genoeg voor de meeste artikelen en voorkomt dat een lange pagina de context vult. Een model dat meerdere pagina's in één antwoord leest, doet het beter met 8.000 tot 12.000 per pagina.

Vraag het model alleen de pagina's te lezen die het nodig heeft, niet elke link die het ziet. Een korte zin in je projectinstructies, zoals "lees maximaal drie pagina's per vraag", houdt zowel de kosten als de context in de hand.

## Wat gebeurt er als een site het lezen weigert?

De tool geeft een kort bericht terug met de foutcode, zoals `blocked_by_robots` of `target_refused`, en er wordt niets gefactureerd. We respecteren robots.txt: onze crawler identificeert zich als WebReaderAPI, volgt de regels die voor hem of voor alle robots zijn geschreven, en leest geen pagina die een site niet toestaat. Geweigerde pagina's worden niet in rekening gebracht. Als een site ons verzoek weigert, geven we het antwoord terug: we lossen nooit CAPTCHA's op, loggen niet in op accounts en proberen nooit een blokkade of paywall te omzeilen. Het model kan dan zeggen dat de pagina niet beschikbaar is voor geautomatiseerde lezers en een andere bron gebruiken.

## MCP-server: veelgestelde vragen

### Is er een officieel WebReaderAPI MCP-package?

Nee. Het bestand op deze pagina is de integratie: 40 regels die je zelf kunt lezen, aanpassen en draaien. Niets om bij ons te installeren, en je sleutel verlaat je machine nooit, behalve in calls naar onze API.

### Kan het model met deze server het web doorzoeken?

Nee. `read_url` leest een pagina waarvan jij of het model het adres al heeft. Combineer hem met elke zoektool die je client biedt; het model zoekt en leest dan de pagina's die ertoe doen.

### Hoeveel kost een assistant om mee te draaien?

Eén credit per gelezen pagina, twee wanneer een browser nodig is. Een assistant die 50 pagina's per dag leest, gebruikt ongeveer 1.500 credits per maand, en 10.000 pagina's (US$ 3,75) dekt dat ongeveer zes maanden.

### Werkt de server offline?

Nee. Hij roept `https://webreaderapi.com/api/v1/read` aan voor elke pagina, dus hij heeft internettoegang en een geldige sleutel nodig.

---

WebReaderAPI: WebReaderAPI is een web reader-API voor AI-agents die elke openbare webpagina omzet in schone Markdown, betaald met crypto zonder ID te uploaden. Prepaid credits vanaf US$ 0,07/1K pagina's verlopen nooit, en robots.txt wordt gerespecteerd. Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto.
