Fetch MCP

Official MCP reference server for fetching and converting web content to markdown.

Description

What Fetch MCP is for

Fetch MCP is the official Model Context Protocol reference server for retrieving web content. It is maintained in the modelcontextprotocol/servers repository; the published Python package is called mcp-server-fetch and, according to the project, is licensed under MIT. Its practical value is straightforward: an AI agent can receive a URL, fetch the page through a controlled MCP tool, convert the content to Markdown, and then reason over that text inside the conversation or coding workflow. For Skill Road, Fetch MCP belongs in the research category because many useful agent workflows start with bringing documentation, changelogs, public issues, pricing pages, or blog posts into model-readable context.

Capabilities, boundaries, and common workflows

According to the official README, the server exposes one tool named fetch. The required input is the URL; optional parameters include max_length, start_index, and raw. max_length limits the returned text, start_index allows the model to continue from a later character position, and raw returns unprocessed HTML instead of Markdown. This small API is more useful than it first looks. Large pages do not need to be pushed into the model window all at once; an agent can read the opening section, decide what matters, and then request a later chunk when needed.

The boundary matters. Fetch MCP is not a full browser with login handling, clicking, JavaScript execution, screenshots, or visual QA. It works best for public content that can be retrieved directly and already contains the relevant information in the server response. Highly dynamic pages, account-only content, paywalls, Cloudflare challenges, or interactive pricing tables require a different tool. As a lightweight research building block, however, Fetch MCP is still valuable because it is far simpler than browser automation and fits naturally into Claude Desktop, VS Code, Codex-style, Cursor, and other MCP-capable setups.

Installation and operation

The documentation recommends uv and uvx. With uv installed, the server can be started without a separate permanent package installation through uvx mcp-server-fetch. Alternatives are pip install mcp-server-fetch followed by python -m mcp_server_fetch, or the official Docker image mcp/fetch. Node.js is optional; per the README, installing it lets the server use a more robust HTML simplifier. The package currently depends on MCP Python SDK 1.x with mcp>=1.29.0,<2, while the port to SDK 2.0 is still in progress according to the project.

In Claude Desktop, VS Code, and similar MCP hosts, the server is registered as a stdio command. A typical configuration uses command uvx and args ["mcp-server-fetch"]. For teams, that simplicity is attractive: there are no API keys to distribute and no third-party account connection to maintain. At the same time, the runtime environment should be chosen deliberately. The tool needs outbound network access and sends the requested URL, ordinary HTTP metadata, and any configured proxy settings to the target site or proxy.

Security, robots.txt, and data handling

The official documentation contains an explicit caution: Fetch MCP can access local and internal IP addresses. That creates an SSRF and data-exfiltration risk if an agent is allowed to follow arbitrary URLs from untrusted content. Production-like setups should restrict network access, block private address ranges, and avoid letting models generate sensitive internal URLs. By default, the server respects robots.txt for model-initiated requests; the --ignore-robots-txt flag can disable that behavior, but it should only be used after a conscious review of the source and purpose.

In daily use, Fetch MCP should therefore be treated as a focused research channel rather than an unrestricted internet opening for the model. Good prompts define which source should be read, which parts matter, and when the agent should stop requesting more chunks. For SEO research, technical documentation, or vendor verification, that constraint is useful because the origin of each claim remains visible. For Skill Road, this is central: product claims should be checked against primary sources, not copied from directories. Fetch MCP can quickly turn those primary sources into Markdown, but deciding whether a statement is current, reliable, or merely vendor marketing remains editorial work.

Another practical advantage is how well it combines with other tools. Fetch MCP can retrieve public documentation, Filesystem MCP can place the result into local notes or tests, and a coding agent can prepare concrete changes from that material. Teams using this pattern should still set firm boundaries: no secret internal URLs, no blind obedience to instructions embedded in web pages, and no unreviewed write actions after a web lookup. Used that way, Fetch MCP remains a useful research component instead of becoming an uncontrolled data channel.

Who benefits most from Fetch MCP?

Fetch MCP is useful for developers, researchers, and editorial teams that regularly need public web sources in structured, model-readable form without running a full browser controller. Common questions are easy to answer: Can it read logged-in pages? Not as a reliable browser replacement. Is it free? The server itself is open source; only your own runtime, network, or proxy infrastructure may cost money. Is it safe? It can be, but only with constrained network access. Its value is that balance: fast web retrieval for AI agents, with clear operational limits.

For straightforward fact checking, the server is often faster than manually copying text from a browser. An agent can load a project page, summarize the relevant sections, and then search for a version number, installation note, license sentence, or security warning inside the fetched material. Content teams can use the same pattern when writing catalog entries, tool reviews, or technical comparisons: retrieve the primary source during the workflow, then turn it into careful, attributable statements. The fetched page should still not be treated as automatically correct. Websites change, vendor copy contains marketing, and a result returned through Fetch MCP only proves what was visible at that URL at retrieval time.

Fetch MCP is not the right tool when the visible state of a page matters. Cookie banners, login flows, checkout steps, interactive tables, screenshots, accessibility testing, and JavaScript-heavy experiences require browser tooling. That boundary is the reason this entry is useful: Fetch MCP is not a universal web agent, but a small, reliable component for public web text. Used in that role, it is valuable for research, documentation work, technical due diligence, and quick source verification.

Requirements

Python 3.10 or newer and an MCP client. uv with uvx is recommended; pip or Docker are alternatives. The package currently uses MCP Python SDK 1.x (mcp>=1.29.0,<2). Node.js is optional and enables a more robust HTML simplifier.

Installation instructions

Fetch MCP retrieves web pages and converts their HTML into compact Markdown for the MCP client. The recommended installation uses uvx.

Requirements for Fetch MCP

You need Python 3.10 or newer, an MCP client, and uv. Node.js is optional; when present, the server uses a more robust HTML simplifier.

Step 1: Starting Fetch MCP with uvx

bash
uvx mcp-server-fetch

Configure uvx as the command and mcp-server-fetch as its argument in the MCP client. Alternatively, install the package with pip install mcp-server-fetch and run python -m mcp_server_fetch. The mcp/fetch image is documented as well.

bash
pip install mcp-server-fetch
python -m mcp_server_fetch

Establishing a security boundary for Fetch MCP

The official server can reach local and internal IP addresses. Run it in an environment whose network access is limited to required public targets. A proxy can be set with --proxy-url. Model-initiated requests honor robots.txt by default; use --ignore-robots-txt only deliberately.

Step 2: Verifying the setup

First retrieve a harmless public page and confirm that Markdown is returned. Then verify from the runtime environment that internal administration interfaces and metadata endpoints are not reachable.

Common startup issues

If uvx mcp-server-fetch fails with an error about the Python version, check with python3 --version — at least version 3.10 is required. If uv is missing from the system, it can be installed following the official installation guide; alternatively, the pip install mcp-server-fetch path works without uv. If the server unexpectedly returns empty or truncated results, that can be caused by a max_length parameter set too low, which limits the amount of returned text.

bash
uvx mcp-server-fetch
python3 --version
pip install mcp-server-fetch

Step 3: Proxy and network configuration

In enterprise environments that require an outbound proxy, it must be passed to the server via --proxy-url, otherwise all requests fail. Firewalls that only allow specific destination addresses should account for the server process itself, not just the MCP client, since the actual HTTP requests originate from the fetch process.

When ignoring robots.txt is justified

By default, the server respects robots.txt for model-initiated requests. The --ignore-robots-txt flag should only be set in clearly justified cases, such as accessing your own, self-controlled internal documentation whose robots.txt was accidentally configured too restrictively. For third-party public websites, ignoring robots.txt is not recommended.

When Fetch MCP reaches its limits

For pages that rely heavily on JavaScript to load content, or that require a login, Fetch MCP may return incomplete or empty results because the server doesn't simulate a real browser. In such cases, a browser automation tool such as Playwright MCP is the better fit.

Knowing this boundary upfront saves troubleshooting time later, since an empty or truncated response is often a sign the target page needs interactive rendering rather than a configuration error.

Source: official modelcontextprotocol/servers repository and PyPI, checked on 2026-09-03.

uvx mcp-server-fetch

Authentication

The local stdio server has no login of its own. It fetches URLs with its own user agent; general authentication to protected websites is not provided. An optional HTTP proxy is configured with --proxy-url.

Required access permissions

Requires outbound HTTP/HTTPS and DNS access to requested targets. If a proxy is configured, the server must be able to reach it. According to the official warning, the server can also access local and internal IP addresses.

Transmitted or stored data

The requested URL, user agent, and ordinary HTTP metadata are sent to the target website or a configured proxy. Retrieved HTML is converted locally to Markdown or returned raw, then passed to the client and language model. The server documentation does not describe persistent storage.

Security risks

The server can reach internal services and private IP addresses, creating an explicit SSRF and data-exfiltration risk. Retrieved pages may also contain prompt injection or malicious instructions. Restrict network access, block internal targets, avoid sensitive URLs, and use --ignore-robots-txt only after deliberate review.

License and costs

License
MIT
Cost
free

The reference server is free under the MIT license. Your runtime environment, proxies, or requested services may incur costs.

Alternatives

At a glance

Status
Official server
Deployment
Local
Current version
2026.8.18
GitHub stars
91,877
Last reviewed
06.09.2026

Repository and documentation

Categories

Supported clients

Related guides

Guides and background related to this entry.

No related guides yet.