Guide

How to give Claude and Cursor access to the web with MCP

A remote MCP server is one URL and one header. This guide shows the exact configuration for Claude Code, Claude Desktop and Cursor, how to scope the token so an agent can't overspend, the first prompts worth trying and what they cost.

By Roger Campos · Last updated: September 2026

TL;DR

To give Claude or Cursor web access, register a remote MCP server: a streamable-HTTP URL plus an Authorization header. Claude Code takes it with one claude mcp add command; Cursor reads it from .cursor/mcp.json; Claude Desktop needs a small local bridge for header-based auth. Scope the token to what the agent needs, and tell it to read pages as Markdown — the cheapest call and the best input.

Start free See the API

Free plan, no credit card. 1,000 credits a month.

The idea

What "web access with MCP" actually means

The Model Context Protocol is how an AI client discovers and calls tools it doesn't ship with. Give it a server that fetches pages, and the model can read any URL you mention — or decide on its own to look something up.

An MCP server comes in one of two shapes. A local server is a program the client starts on your machine and talks to over stdin and stdout; you install it, keep it updated and give it whatever it needs to run. A remote server runs somewhere else and is reached over HTTP — the client needs a URL and a credential, and nothing else. For web access, remote has a real advantage: the server can run a full browser for you, which is the part you don't want on your laptop.

Whatever server you pick, check one thing before anything else: does it render JavaScript? The reference fetch server doesn't, and on client-rendered pages your agent gets the empty shell. We measured that on three real pages.

Step 1

Get a token, and scope it

A remote server authenticates you with a header, almost always Authorization: Bearer <token>. Treat that token like a credit card: a model that can call a tool will call it, sometimes in a loop, and the token decides what those calls can do.

On URLpipe, MCP uses an organization token, created under your organization's MCP access page. It is separate from the per-project API key the HTTP endpoints take, because an agent works across projects. When you create one you choose:

What it may do — fetch pages and read results, or read past results only. A read-only token can list projects, check usage and retrieve results somebody already paid for, and physically cannot spend credits.
Where — every project, or just one. A token for one project can't touch another's history or budget.
For how long — no expiry, or a date after which it stops working. Good for a demo, a contractor or a one-off research run.

The token is shown once and stored as a hash, so copy it when you create it; deleting it revokes it immediately. Keep it in an environment variable rather than in a config file you might commit.

Keep the token in your environment

# ~/.zshrc or ~/.bashrc
export URLPIPE_TOKEN="paste-your-token-here"

Step 2

Connect Claude Code

Claude Code takes remote servers with headers directly. One command registers the server; --scope decides where the configuration lives — local (the default, this project, only you), project (a .mcp.json in the repository, shared with your team) or user (every project on your machine).

Terminal

claude mcp add --transport http urlpipe https://urlpipe.dev/mcp \
  --scope user \
  --header "Authorization: Bearer $URLPIPE_TOKEN"

Your shell expands $URLPIPE_TOKEN when you run that, so the stored config holds the token itself — fine for local and user scope, which live in your home directory. For a shared .mcp.json, write the file by hand and let Claude Code expand the variable at startup instead; it supports ${VAR} in URLs and headers.

.mcp.json (safe to commit)

{
  "mcpServers": {
    "urlpipe": {
      "type": "http",
      "url": "https://urlpipe.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${URLPIPE_TOKEN}"
      }
    }
  }
}

Run /mcp inside Claude Code to confirm the server is connected and see its tools.

Step 3

Connect Cursor

Cursor reads MCP servers from .cursor/mcp.json in a project, or ~/.cursor/mcp.json for every project. A remote server is a url and headers, and Cursor expands ${env:NAME} in both, so the file never has to contain the token.

~/.cursor/mcp.json

{
  "mcpServers": {
    "urlpipe": {
      "url": "https://urlpipe.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${env:URLPIPE_TOKEN}"
      }
    }
  }
}

Cursor only sees environment variables that were set when it started, so restart it after adding one. The server then appears under MCP in Cursor's settings, with its tools listed; the agent uses them when a task calls for it, or when you ask by name.

Step 4

Connect Claude Desktop

Claude's own connector screen — Customize → Connectors → Add custom connector on individual plans — takes a server URL and handles sign-in with OAuth. It has no field for a custom header, so a server that authenticates with a bearer token, like URLpipe's, can't be added there directly.

The widely used workaround is mcp-remote, a small bridge Claude Desktop starts as a local server and which forwards every request to the remote one with your header attached. It needs Node.js. Add it to claude_desktop_config.json (Settings → Developer → Edit Config) and restart Claude:

claude_desktop_config.json

{
  "mcpServers": {
    "urlpipe": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://urlpipe.dev/mcp",
        "--header",
        "Authorization:${URLPIPE_AUTH}"
      ],
      "env": {
        "URLPIPE_AUTH": "Bearer paste-your-token-here"
      }
    }
  }
}

Why no space after the colon

mcp-remote's documentation notes that some clients, Claude Desktop on Windows among them, don't escape spaces inside args, which splits Authorization: Bearer … into pieces. Putting the whole value, space included, in an environment variable avoids it.

Step 5

First prompts worth trying

Once connected, you don't call tools yourself — you ask, and the model picks. These prompts exercise the common cases and show quickly whether the setup works:

"Read https://example.com/pricing and give me the plans as a table." — a fetch_markdown call; the fastest check that pages come back with their content.
"Take a screenshot of our homepage at 390 px wide and tell me what's above the fold." — a capture_screenshot call with a phone viewport.
"Run a Lighthouse audit on this URL and list the three insights that would help LCP most." — slow, so the agent gets a token back and collects the result with get_result.
"Check these five pages for JavaScript errors and group them by message." — five console_logs calls.
"How many credits do I have left, and what would reading these 200 URLs cost?" — get_usage, which returns your balance and each operation's price.

Async is the default on URLpipe's MCP server, as on its HTTP API: a call returns a token straight away and the agent fetches the result later. Agents handle this fine, but if you'd rather it waited, say so — "use sync: true" — and each call returns the result directly.

Costs

What an agent session costs

A model deciding for itself when to call tools is a model deciding how to spend your money, so it pays to know the price list. On URLpipe an MCP call costs exactly what the matching HTTP endpoint costs, from the same monthly allowance — there is no MCP surcharge:

Tool	Credits per call	Use it for
fetch_markdown	1	Reading a page. The default.
fetch_html, capture_screenshot, console_logs	1	Markup, an image, JavaScript errors
lighthouse_audit	2	A performance and quality audit
extract_metadata	5	Title, author, date, share image
extract_keywords	15	When the keyword list is the deliverable
summarize_page	17	When the summary is the deliverable

The trap is summarize_page. An agent that wants to understand a page tends to reach for "summarize", which costs 17 times as much as reading the Markdown and hands the model a lossy version of the page it could have read itself. The server tells the model this at connection time, and a line in your own instructions — "read pages with fetch_markdown" — makes it stick.

Two things keep a long session cheap without you doing anything. A page your organization fetched in the last seven days is served from the cache for free, and a failed fetch is never billed. The server is rate limited to 300 calls per five minutes per token, and your plan's parallel-request limit applies, so a runaway loop hits a ceiling rather than your invoice. The pricing page has the plans.

When it doesn't work

Troubleshooting a remote MCP server

The server shows as failed or has no tools — usually the header. Check the token wasn't truncated when you copied it, and that the variable it comes from was set before the client started.
401 errors — the header is missing or the token isn't valid: deleted, expired or mistyped. The response deliberately doesn't say which, so create a fresh token if in doubt.
403 with email_unverified — confirm your account's email address to activate API access; the dashboard works either way.
Tool calls return a quota or concurrency error — the body is the API's own error object, and the errors page says what each code means.
The agent ignores the tools — mention the server by name in the prompt ("use urlpipe to read…"), or add a line to your project instructions saying when to use it.

The full tool list, every argument and the async behaviour are in the MCP server docs.

FAQ

Frequently asked questions

What is a remote MCP server?

An MCP server that runs on someone else's machine and is reached over HTTP, rather than a program your client starts locally. There is nothing to install: the client needs the server's URL and a credential, usually an Authorization header.

Can I add a bearer-token MCP server in Claude Desktop?

Claude's built-in custom connectors expect OAuth or no authentication. For a server that takes a bearer token, run a small bridge such as mcp-remote from claude_desktop_config.json, which forwards the requests with your header. Claude Code and Cursor take headers directly.

Where do I keep the token so it isn't committed to git?

In an environment variable. Claude Code expands ${VAR} inside .mcp.json and Cursor expands ${env:VAR} inside mcp.json, so the file in version control holds only the variable's name.

How do I stop an agent from spending too much?

Give it the narrowest token that does the job: read-only if it only needs past results, limited to one project, with an expiry date. Tell it which tool is cheapest for reading, and check usage with get_usage before a large run.

Does a call through MCP cost more than the HTTP API?

Not on URLpipe: an MCP call spends exactly what the matching endpoint spends, from the same monthly allowance, and cache hits are free either way.

Try it yourself

Free tools for this

No signup — run these on a real page right now, then call the same endpoint from your code.

/mcp API docs /credits API docs

Keep reading

Why AI agents read empty pages HTML to Markdown for LLMs Reading a Lighthouse audit Rendered vs. raw HTML Extracting page metadata All guides

Put this into practice.

Each of the eight kinds of data URLpipe returns has a free, no-signup tool — try the ideas from this guide on a real page, then grab an API key to run them from your code. 1,000 credits a month, no card.

Start free Email the team