# MCP server web page reader per Claude, Cursor e altri client MCP

> MCP server web page reader per Claude Desktop e Cursor: un tool Python read_url da 40 righe che restituisce Markdown pulito. Paghi in criptovalute.

- URL: https://webreaderapi.com/it/docs/mcp/
- Ultimo aggiornamento: 2026-10-22
- Editore: WebReaderAPI (https://webreaderapi.com)

Dai a qualsiasi client MCP un tool `read_url` che converte un link in Markdown pulito. Il server è un unico file Python breve che esegui sulla tua macchina; la tua chiave API resta nel suo ambiente.

**Risposta rapida — Come aggiungo un web page reader a Claude Desktop o Cursor con MCP?**

Esegui un piccolo MCP server che espone un tool `read_url` che chiama **WebReaderAPI**, poi registralo nelle impostazioni MCP del tuo client con la tua chiave in `env`. Il modello può così leggere qualsiasi pagina pubblica come Markdown pulito. Ogni pagina letta costa 1 credito, 2 con un browser, a partire da 0,07 USD/1K pagine a ottobre 2026. Senza KYC; paghi in criptovalute.

## Il MCP server in sintesi

| Attributo | Valore |
| --- | --- |
| Linguaggio | Python 3.10+, con i pacchetti `mcp` e `httpx` |
| Trasporto | stdio: il client avvia il server come processo locale |
| Strumento | `read_url(url, max_chars)` → titolo, URL di origine, poi il Markdown della pagina |
| Perché non web_fetch | Claude Code e OpenClaw includono già un tool integrato con quel nome |
| Chiave | Letta da `WEBREADER_API_KEY` nell'ambiente del server |
| Fatturazione | 1 credito = 1 pagina letta senza browser; 2 crediti quando la pagina richiede un browser per eseguire JavaScript. Una richiesta che fallisce, o che il robots.txt di un sito rifiuta, non viene addebitata |

## Perché un tool read_url e non web_fetch?

Perché due tool con lo stesso nome confondono sia il client sia il modello. Claude Code e OpenClaw includono già un tool chiamato `web_fetch`. Un nome distinto, `read_url`, e una descrizione chiara permettono al modello di scegliere il nostro quando serve il contenuto principale di una pagina, comprese le pagine JavaScript e i PDF.

Il tool restituisce testo, non JSON. I modelli gestiscono meglio un'intestazione breve e il Markdown rispetto ai campi annidati, e l'intestazione tiene l'URL di origine in vista così la risposta può citarlo.

*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()

```

## Come installo e provo il server?

Crea un ambiente virtuale, installa `mcp` e `httpx` e salva il file qui sopra. Il pacchetto `mcp` è l'SDK Python ufficiale del Model Context Protocol; `FastMCP` trasforma una funzione Python tipizzata in un tool, usando la docstring come descrizione.

Prima di collegarlo a un client, esegui il file una volta da terminale con la tua chiave impostata. Attende in silenzio un client su stdin, il che significa che è partito correttamente; fermalo con Ctrl+C.

*Installazione*

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

## Come lo registro in Claude Desktop?

Apri le impostazioni per sviluppatori di Claude Desktop, modifica `claude_desktop_config.json` e aggiungi una voce sotto `mcpServers`. Usa percorsi assoluti: il Python del tuo ambiente virtuale e il file del server. Metti la chiave in `env`, così non compare mai negli argomenti del tool né nella conversazione. Riavvia Claude Desktop e `read_url` appare nell'elenco dei tool.

Cursor legge la stessa struttura `mcpServers` dal suo file di configurazione MCP, e Claude Code può registrare lo stesso comando con il suo comando `claude mcp add`. Per OpenClaw, vedi la [pagina OpenClaw](https://webreaderapi.com/it/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" }
    }
  }
}
```

## Come mantengo le pagine entro il contesto del modello?

Riduci `max_chars`. Il valore predefinito di 20.000 caratteri basta per la maggior parte degli articoli e impedisce che una pagina lunga riempia il contesto. Un modello che legge più pagine in una sola risposta rende meglio con 8.000-12.000 caratteri per pagina.

Chiedi al modello di leggere le pagine che gli servono, non ogni link che vede. Una frase breve nelle istruzioni del tuo progetto, come "leggi al massimo tre pagine per domanda", tiene sotto controllo sia il costo sia il contesto.

## Cosa succede quando un sito rifiuta la lettura?

Il tool restituisce un messaggio breve con il codice di errore, come `blocked_by_robots` o `target_refused`, e non viene addebitato nulla. Rispettiamo robots.txt: il nostro crawler si identifica come WebReaderAPI, segue le regole scritte per lui o per tutti i robot e non legge una pagina che un sito vieta. Le pagine rifiutate non vengono addebitate. Se un sito rifiuta la nostra richiesta, restituiamo la sua risposta: non risolviamo mai CAPTCHA, non accediamo agli account e non tentiamo di aggirare un blocco o un paywall. Il modello può quindi dire che la pagina non è disponibile ai lettori automatizzati e usare un'altra fonte.

## MCP server: domande frequenti

### Esiste un pacchetto MCP ufficiale di WebReaderAPI?

No. Il file in questa pagina è l'integrazione: 40 righe che puoi leggere, modificare ed eseguire da solo. Niente da installare da parte nostra, e la tua chiave non lascia mai la tua macchina se non nelle chiamate alla nostra API.

### Il modello può cercare sul web con questo server?

No. `read_url` legge una pagina di cui tu o il modello avete già l'indirizzo. Abbinalo a qualsiasi tool di ricerca offerto dal tuo client; il modello cerca, poi legge le pagine che contano.

### Quanto costa far funzionare un assistente con questo server?

Un credito per pagina letta, due quando serve un browser. Un assistente che legge 50 pagine al giorno usa circa 1.500 crediti al mese, e 10.000 pagine (3,75 USD) li copre per circa sei mesi.

### Il server funziona offline?

No. Chiama `https://webreaderapi.com/api/v1/read` per ogni pagina, quindi serve accesso a internet e una chiave valida.

---

WebReaderAPI: WebReaderAPI è un'API web reader per agenti AI che converte qualsiasi pagina web pubblica in Markdown pulito, con pagamento in criptovalute e senza caricare documenti d'identità. I crediti prepagati da 0,07 USD/1K pagine non scadono mai e robots.txt viene rispettato. Senza KYC — niente documento, niente selfie, niente documenti. Paga in criptovalute.
