# Servidor MCP de lectura de páginas web para Claude, Cursor y otros clientes MCP

> Servidor MCP de lectura web para Claude Desktop y Cursor: una herramienta read_url en Python que devuelve Markdown limpio. Sin KYC, paga con criptomonedas.

- URL: https://webreaderapi.com/es/docs/mcp/
- Última actualización: 2026-10-22
- Editor: WebReaderAPI (https://webreaderapi.com)

Dale a cualquier cliente MCP una herramienta `read_url` que convierte un enlace en Markdown limpio. El servidor es un único archivo Python corto que ejecutas en tu propia máquina; tu clave API se queda en su entorno.

**Respuesta rápida — ¿Cómo añado un lector de páginas web a Claude Desktop o Cursor con MCP?**

Ejecuta un pequeño servidor MCP que exponga una herramienta `read_url` que llame a **WebReaderAPI** y luego regístralo en los ajustes MCP de tu cliente con tu clave en `env`. El modelo podrá entonces leer cualquier página pública como Markdown limpio. Cada lectura de página cuesta 1 crédito, 2 con navegador, desde 0,07 US$/1K páginas a octubre de 2026. Sin KYC; paga con criptomonedas.

## El servidor MCP de un vistazo

| Atributo | Valor |
| --- | --- |
| Lenguaje | Python 3.10+, con los paquetes `mcp` y `httpx` |
| Transporte | stdio: el cliente inicia el servidor como proceso local |
| Herramienta | `read_url(url, max_chars)` → título, URL de origen y luego el Markdown de la página |
| Por qué no web_fetch | Claude Code y OpenClaw ya incluyen una herramienta integrada con ese nombre |
| Clave | Se lee de `WEBREADER_API_KEY` en el entorno del servidor |
| Facturación | 1 crédito = 1 página leída sin navegador; 2 créditos cuando la página necesita un navegador para renderizar JavaScript. Una solicitud que falla, o que el robots.txt de un sitio rechaza, no se cobra |

## ¿Por qué una herramienta read_url y no web_fetch?

Porque dos herramientas con el mismo nombre confunden tanto al cliente como al modelo. Claude Code y OpenClaw ya incluyen una herramienta llamada `web_fetch`. Un nombre distinto, `read_url`, y una descripción clara permiten al modelo elegir la nuestra cuando necesita el contenido principal de una página, incluidas páginas con JavaScript y PDFs.

La herramienta devuelve texto, no JSON. Los modelos manejan mejor una cabecera corta y Markdown que campos anidados, y la cabecera mantiene visible la URL de origen para que la respuesta pueda citarla.

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

```

## ¿Cómo instalo y pruebo el servidor?

Crea un entorno virtual, instala `mcp` y `httpx`, y guarda el archivo de arriba. El paquete `mcp` es el SDK oficial de Python del Model Context Protocol; `FastMCP` convierte una función Python tipada en una herramienta, usando el docstring como descripción.

Antes de conectarlo a un cliente, ejecuta el archivo una vez desde un terminal con tu clave configurada. Se queda esperando en silencio a un cliente en stdin, lo que significa que se inició correctamente; detenlo con Ctrl+C.

*Instalación*

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

## ¿Cómo lo registro en Claude Desktop?

Abre los ajustes de desarrollador de Claude Desktop, edita `claude_desktop_config.json` y añade una entrada bajo `mcpServers`. Usa rutas absolutas: el Python de tu entorno virtual y el archivo del servidor. Pon la clave en `env`, para que nunca aparezca en los argumentos de la herramienta ni en la conversación. Reinicia Claude Desktop y `read_url` aparecerá en la lista de herramientas.

Cursor lee la misma estructura `mcpServers` desde su propio archivo de configuración MCP, y Claude Code puede registrar el mismo comando con su comando `claude mcp add`. Para OpenClaw, consulta la [página de OpenClaw](https://webreaderapi.com/es/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" }
    }
  }
}
```

## ¿Cómo mantengo las páginas dentro del contexto del modelo?

Baja `max_chars`. El valor por defecto de 20.000 caracteres es suficiente para la mayoría de los artículos y evita que una página larga llene el contexto. Un modelo que lee varias páginas en una sola respuesta funciona mejor con 8.000 a 12.000 por página.

Pide al modelo que lea las páginas que necesita, no todos los enlaces que ve. Una frase corta en las instrucciones de tu proyecto, como "lee como máximo tres páginas por pregunta", mantiene a raya tanto el coste como el contexto.

## ¿Qué pasa cuando un sitio rechaza la lectura?

La herramienta devuelve un mensaje corto con el código de error, como `blocked_by_robots` o `target_refused`, y no se factura nada. Respetamos robots.txt: nuestro rastreador se identifica como WebReaderAPI, sigue las reglas escritas para él o para todos los robots y no lee una página que un sitio prohíbe. Las páginas rechazadas no se cobran. Si un sitio rechaza nuestra solicitud, devolvemos su respuesta: nunca resolvemos CAPTCHAs, iniciamos sesión en cuentas ni intentamos saltar un bloqueo o un paywall. El modelo puede entonces indicar que la página no está disponible para lectores automatizados y usar otra fuente.

## Servidor MCP: preguntas frecuentes

### ¿Existe un paquete MCP oficial de WebReaderAPI?

No. El archivo de esta página es la integración: 40 líneas que puedes leer, cambiar y ejecutar tú mismo. No hay nada que instalar de nuestra parte, y tu clave nunca sale de tu máquina salvo en las llamadas a nuestra API.

### ¿Puede el modelo buscar en la web con este servidor?

No. `read_url` lee una página cuya dirección ya tienes tú o el modelo. Combínalo con cualquier herramienta de búsqueda que ofrezca tu cliente; el modelo busca y luego lee las páginas que importan.

### ¿Cuánto cuesta ejecutar un asistente con esto?

Un crédito por página leída, dos cuando se necesita un navegador. Un asistente que lee 50 páginas al día usa unos 1.500 créditos al mes, y 10.000 páginas (3,75 US$) lo cubre durante unos seis meses.

### ¿Funciona el servidor sin conexión?

No. Llama a `https://webreaderapi.com/api/v1/read` para cada página, así que necesita acceso a internet y una clave válida.

---

WebReaderAPI: WebReaderAPI es una API de lectura web para agentes de IA que convierte cualquier página web pública en Markdown limpio, pagando con criptomonedas y sin subir ningún documento de identidad. Los créditos prepago desde 0,07 US$/1K páginas nunca caducan y se respeta robots.txt. Sin KYC: ni documento de identidad, ni selfie, ni documentos. Paga con criptomonedas.
