# Servidor MCP de leitura de páginas web para Claude, Cursor e outros clientes MCP

> Leitura de páginas web para clientes MCP como Claude Desktop e Cursor: ferramenta read_url em Python de 40 linhas com Markdown limpo. Sem KYC, pague com cripto.

- URL: https://webreaderapi.com/pt/docs/mcp/
- Última atualização: 2026-10-22
- Editor: WebReaderAPI (https://webreaderapi.com)

Dê a qualquer cliente MCP uma ferramenta `read_url` que converte um link em Markdown limpo. O servidor é um único arquivo Python curto que você executa na sua própria máquina; sua chave de API fica no ambiente dele.

**Resposta rápida — Como adiciono um leitor de páginas web ao Claude Desktop ou ao Cursor com MCP?**

Execute um pequeno servidor MCP que expõe uma ferramenta `read_url` chamando **WebReaderAPI** e depois registre-o nas configurações MCP do seu cliente, com sua chave em `env`. O modelo então pode ler qualquer página pública como Markdown limpo. Cada leitura de página custa 1 crédito, 2 com navegador, a partir de US$ 0,07/1K páginas em outubro de 2026. Sem KYC; pague com cripto.

## O servidor MCP em resumo

| Atributo | Valor |
| --- | --- |
| Linguagem | Python 3.10+, com os pacotes `mcp` e `httpx` |
| Transporte | stdio: o cliente inicia o servidor como um processo local |
| Ferramenta | `read_url(url, max_chars)` → título, URL de origem e depois o Markdown da página |
| Por que não web_fetch | O Claude Code e o OpenClaw já trazem uma ferramenta embutida com esse nome |
| Chave | Lida de `WEBREADER_API_KEY` no ambiente do servidor |
| Cobrança | 1 crédito = 1 página lida sem navegador; 2 créditos quando a página precisa de um navegador para renderizar JavaScript. Uma requisição que falha, ou que o robots.txt de um site recusa, não é cobrada |

## Por que uma ferramenta read_url e não web_fetch?

Porque duas ferramentas com o mesmo nome confundem tanto o cliente quanto o modelo. O Claude Code e o OpenClaw já incluem uma ferramenta chamada `web_fetch`. Um nome distinto, `read_url`, e uma descrição clara permitem que o modelo escolha a nossa quando precisa do conteúdo principal de uma página, inclusive de páginas com JavaScript e PDFs.

A ferramenta retorna texto, não JSON. Os modelos lidam melhor com um cabeçalho curto e Markdown do que com campos aninhados, e o cabeçalho mantém a URL de origem à vista para que a resposta possa citá-la.

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

```

## Como instalo e testo o servidor?

Crie um ambiente virtual, instale `mcp` e `httpx` e salve o arquivo acima. O pacote `mcp` é o SDK oficial de Python do Model Context Protocol; `FastMCP` transforma uma função Python tipada em ferramenta, usando a docstring como descrição.

Antes de conectá-lo a um cliente, execute o arquivo uma vez no terminal com sua chave definida. Ele fica aguardando silenciosamente um cliente no stdin, o que significa que iniciou corretamente; pare-o com Ctrl+C.

*Instalar*

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

## Como registro ele no Claude Desktop?

Abra as configurações de desenvolvedor do Claude Desktop, edite `claude_desktop_config.json` e adicione uma entrada em `mcpServers`. Use caminhos absolutos: o Python do seu ambiente virtual e o arquivo do servidor. Coloque a chave em `env`, para que ela nunca apareça nos argumentos da ferramenta nem na conversa. Reinicie o Claude Desktop e `read_url` aparece na lista de ferramentas.

O Cursor lê a mesma estrutura de `mcpServers` no seu próprio arquivo de configuração MCP, e o Claude Code pode registrar o mesmo comando com seu comando `claude mcp add`. Para o OpenClaw, veja a [página do OpenClaw](https://webreaderapi.com/pt/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" }
    }
  }
}
```

## Como mantenho as páginas dentro do contexto do modelo?

Diminua `max_chars`. O padrão de 20.000 caracteres é suficiente para a maioria dos artigos e impede que uma página longa ocupe todo o contexto. Um modelo que lê várias páginas em uma única resposta se sai melhor com 8.000 a 12.000 caracteres por página.

Peça ao modelo para ler as páginas de que precisa, não todos os links que vê. Uma frase curta nas instruções do seu projeto, como "leia no máximo três páginas por pergunta", mantém custo e contexto sob controle.

## O que acontece quando um site recusa a leitura?

A ferramenta retorna uma mensagem curta com o código de erro, como `blocked_by_robots` ou `target_refused`, e nada é cobrado. Respeitamos o robots.txt: nosso crawler se identifica como WebReaderAPI, segue as regras escritas para ele ou para todos os robôs e não lê uma página que o site proíbe. Páginas recusadas não são cobradas. Se um site recusa nossa requisição, devolvemos a resposta dele: nunca resolvemos CAPTCHAs, nunca entramos em contas e nunca tentamos contornar um bloqueio ou um paywall. O modelo pode então dizer que a página não está disponível para leitores automatizados e usar outra fonte.

## Servidor MCP: perguntas frequentes

### Existe um pacote MCP oficial do WebReaderAPI?

Não. O arquivo desta página é a integração: 40 linhas que você pode ler, alterar e executar por conta própria. Nada para instalar da nossa parte, e sua chave nunca sai da sua máquina, exceto nas chamadas à nossa API.

### O modelo pode pesquisar na web com este servidor?

Não. `read_url` lê uma página cujo endereço você ou o modelo já têm. Combine com qualquer ferramenta de pesquisa que seu cliente ofereça; o modelo pesquisa e depois lê as páginas que importam.

### Quanto custa rodar um assistente com ele?

Um crédito por leitura de página, dois quando um navegador é necessário. Um assistente que lê 50 páginas por dia usa cerca de 1.500 créditos por mês, e 10.000 páginas (US$ 3,75) cobre isso por cerca de seis meses.

### O servidor funciona offline?

Não. Ele chama `https://webreaderapi.com/api/v1/read` para cada página, então precisa de acesso à internet e de uma chave válida.

---

WebReaderAPI: O WebReaderAPI é uma API de leitor web para agentes de IA que converte qualquer página web pública em Markdown limpo, pago com cripto e sem envio de documentos. Os créditos pré-pagos a partir de US$ 0,07/1K páginas nunca expiram, e o robots.txt é respeitado. Sem KYC — sem documento, sem selfie, sem envio de arquivos. Pague com cripto.
