# Fetch

> Retrieve web pages and convert them to clean markdown.

[Canonical HTML page](https://top-mcps.com/mcp/fetch) · [server.json](https://top-mcps.com/mcp/fetch.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add fetch -- uvx mcp-server-fetch
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": [
        "mcp-server-fetch"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "uvx",
          "args": [
            "mcp-server-fetch"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.fetch]
command = "uvx"
args = [
  "mcp-server-fetch",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "fetch": {
      "command": {
        "path": "uvx",
        "args": [
          "mcp-server-fetch"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Fetch doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Anthropic (modelcontextprotocol)
- **Transport:** stdio
- **Auth model:** None
- **Required secrets:** None
- **Supported clients:** Claude, Cursor, Any MCP-compatible client
- **License:** MIT
- **Language:** Python
- **Latest version:** latest
- **Last verified:** 2026-05-31
- **GitHub stars:** 84,102 (fetched 2026-06-02T11:55:51.467Z)
- **Score:** 93/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/modelcontextprotocol/servers/tree/main/src/fetch

## Tools & permissions

| Tool | Description | Args | Side effects |
|------|-------------|------|--------------|
| `fetch` | Fetch a URL and return its content converted to markdown. | `url: string, max_length?: number, start_index?: number, raw?: boolean` | network |

## Security & scope

- **Access scope:** network
- **Sandbox:** Makes outbound HTTP(S) requests to the URL given in the tool call. No authentication or proxy support by default.
- **Gotchas:**
  - No URL allow-list by default — the agent can fetch any public URL. Combine with a client-side approval step for sensitive workflows.
  - Large pages are truncated; do not rely on it for >~1MB documents.

## Quick answer

**What it does.** Fetches a URL and returns the page content converted to markdown, stripping ads, navigation, and irrelevant markup.

**Best for:**
- Documentation reading
- Article summarization
- Public web page extraction
- Link analysis
- Text extraction

**Not for:**
- JavaScript-heavy SPAs
- Login-required pages
- Real-time web search

## Recipes

### Summarise an article from the open web

```
Fetch https://modelcontextprotocol.io and summarise in three bullets: (1) what MCP is, (2) which clients support it today, (3) the minimum code to write a custom server.
```

_Tested with: Claude Desktop, Cursor_

## Description

The Fetch MCP lets AI models retrieve any web page URL and receive a clean, markdown-formatted version of the content. No API key required. Fast, simple, and useful for reading documentation, articles, and pages inside an AI context.

## Why it matters

Reading web pages is a fundamental research task. This MCP makes any URL readable in a model context without browser overhead.

## Key features

- No API key required
- HTML to markdown conversion
- Fast setup
- Clean text extraction
- Official Anthropic support

## FAQ

### Does it require any API key?

No. The Fetch MCP makes standard HTTP(S) requests with no authentication. That also means you get whatever the target site returns to an anonymous visitor — no logged-in content, no premium articles.

### Can it handle JavaScript-rendered pages?

No. It is a plain HTTP client — it returns the raw HTML the server ships. For single-page apps that only populate content client-side, use the Puppeteer MCP, which renders in a real browser.

### Does it convert HTML to Markdown?

Yes. The default response is Markdown, stripped of navigation and chrome. That cuts tokens by 5-10x versus raw HTML and is usually what you want to feed back into the model.

### Can it follow redirects and handle cookies?

It follows HTTP redirects automatically up to a sane depth. It does not maintain a cookie jar across calls — each fetch is stateless. For session-based scraping you need Puppeteer.

### Are there rate limits?

None imposed by the MCP itself. Be polite on the target side: throttle loops, respect robots.txt, and prefer cached results. Some sites block obvious agent user-agents, so you may see 403s where a browser would succeed.

## Changelog

- **2026-05-31** — Refreshed install snippets and fact sheet; verified for 2026.
- **2024-11-25** — Initial directory listing.