Fetch MCP Server Setup for Cursor IDE (2026)

What does the Fetch MCP server do? It retrieves a specific URL you already have and converts its HTML into clean markdown for the AI to read — no search, no browser rendering, just "get this exact page." Install the official mcp-server-fetch Python package via uvx, add it to ~/.cursor/mcp.json, and Cursor can pull a documentation page, a changelog, or a GitHub issue straight into context instead of you copy-pasting it.

It ships from the same reference-server family as Memory and Sequential Thinking, but unlike those, this one is Python-based and runs via uvx rather than npx.

Fetch vs. Search vs. Browser Automation — Pick the Right Tool

This is the question that actually matters before you install anything:

Fetch does a plain HTTP GET and an HTML-to-markdown conversion — nothing more. A page that renders its real content client-side via JavaScript after load will often come back to Fetch as a near-empty shell, because Fetch never executes that JavaScript. If a page looks suspiciously thin when fetched, that's usually why — reach for Puppeteer instead of assuming the server is broken.

Prerequisites

Step 1: Install uv (If You Don't Have It)

curl -LsSf https://astral.sh/uv/install.sh | sh

Windows: use the PowerShell installer on the same page. Verify with uvx --version.

Step 2: Add the Server to Cursor

Edit ~/.cursor/mcp.json:

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

uvx downloads and runs the package on first use — no separate install step. Restart Cursor and confirm "fetch" shows connected under Settings → MCP.

Step 3: Test With a Real URL

Fetch https://nextjs.org/docs/app/building-your-application/routing 
and summarize the routing conventions in a few bullet points

If you get back an accurate summary referencing real section headings from that page, it's working. If the summary looks generic or wrong, check whether the page is JavaScript-heavy — see the "Fetch vs. Browser Automation" note above.

Handling Long Pages: max_length and start_index

The tool truncates by default so a single fetch doesn't blow out the model's context window on a long page. Two parameters the AI uses (and that you can ask for explicitly) control this:

For a long reference page, the practical pattern is asking the AI to fetch it, then explicitly asking for "the rest of that page" if the answer seems to stop mid-topic — it can call fetch again with a later start_index rather than you re-pasting a URL.

robots.txt: Respected by Default

The reference server checks robots.txt before fetching and will decline pages that disallow it, the same as a well-behaved crawler. This is a deliberate default, not a bug — if a fetch fails with something like a disallow/robots error, the site is telling automated tools not to access that path.

The package does expose a --ignore-robots-txt startup flag for cases where you're fetching your own site's staging environment or an internal tool that happens to have an overly broad robots.txt. Don't reach for it as a default workaround for fetching third-party sites — that flag exists for content you have a legitimate reason to bypass the crawl directive on, not as a general "make errors go away" switch.

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch", "--ignore-robots-txt"]
    }
  }
}

Practical Workflows

Pulling current library docs instead of guessing from training data

Fetch the current React docs page on useEffect cleanup functions 
and check whether the cleanup pattern in this component matches 
current guidance: [paste component]

More reliable than the model recalling a docs page from training data, which may describe an older API version.

Reading a GitHub issue before deciding how to fix something

Fetch https://github.com/vercel/next.js/issues/[number] and tell me 
whether the maintainers confirmed this is a bug or suggested a 
workaround

Comparing your changelog claim against the actual release notes

Fetch the changelog page for [library] version 4.2 and confirm 
whether it actually includes the breaking change I think it does 
before I write a migration note about it

Chaining with Sequential Thinking for a migration decision

Fetch the migration guide at [URL], then use sequential thinking 
to work through whether our current setup needs all the steps 
listed or if some don't apply to our config

What This Doesn't Do

Troubleshooting

Fetch returns almost nothing for a page you know has content
Check if the site renders content via client-side JavaScript. View the page's source (not the rendered DOM) in a browser — if the initial HTML is mostly empty divs, that's what Fetch sees too. Switch to Puppeteer for that page.

"Disallowed by robots.txt" error
The target site's robots.txt blocks that path for crawlers. This is respected by design; only override with --ignore-robots-txt for sites you control or have explicit permission to bypass.

Response gets cut off mid-page
You hit max_length. Ask for the fetch to continue from where it left off — the model can call fetch again with a later start_index on the same URL.

Server doesn't appear in Cursor's MCP panel
Confirm uvx is on your PATH — run uvx mcp-server-fetch --help directly in a terminal. If that fails, the issue is the uv install, not Cursor's config.

Fetch works but the content looks garbled
Some pages return content types Fetch's markdown conversion doesn't handle cleanly (heavily nested tables, embedded widgets). Ask for the raw content instead of the converted markdown if the conversion itself looks broken, so you can see what's actually being returned.

Frequently Asked Questions

Q: Is this the same thing as the Brave Search MCP server?
A: No. Brave Search finds pages for a query and returns a ranked list of snippets. Fetch does the opposite job — it retrieves and reads one specific URL you already have. Most setups that do research work run both: search to find the URL, fetch to actually read it.

Q: Why is this a Python package (uvx) instead of an npm package like most other MCP servers on this site?
A: Anthropic's reference servers split across two SDKs depending on the server — most integration-style servers (Slack, GitHub, Postgres) are TypeScript/npm, while a handful of the more primitive utility servers (Fetch, Git, Time) are Python, run via uv/uvx. Both are equally official; it's just which language the reference implementation happened to be written in.

Q: Can Fetch handle pages that require a login?
A: No. It makes an unauthenticated HTTP request with no cookie or session handling. For anything behind a login, you need browser automation with a persisted session — Puppeteer or Chrome DevTools MCP — not Fetch.

Q: Does it cache pages, so repeated fetches of the same URL are free?
A: No, every fetch call is a fresh HTTP request to the live URL. If a page changed since your last fetch, you get the current version, which is usually what you want — but it also means fetching the same large page repeatedly in one session costs the same each time.

Q: Is it safe to point this at any URL, including ones from an untrusted source?
A: Treat fetched content the same as any other externally-sourced text entering the model's context: a malicious page could include text designed to look like instructions to the AI (a prompt injection attempt). Don't chain a Fetch result directly into a sensitive write-capable tool (like a database or email server) without reviewing what came back first.

Related Guides

---