URLpipe

npx add-mcp 'https://urlpipe.dev/mcp'

Give your AI agent a browser that renders JavaScript

Most fetch tools do a plain HTTP GET, so a JavaScript site comes back empty. This one loads the page in a real browser first — hosted, one token, nothing to run locally.

By Roger Campos · Last updated: September 2026

TL;DR

URLpipe's MCP server is a remote, streamable-HTTP server at https://urlpipe.dev/mcp. Add it to your client with a bearer token and your agent gets 14 tools: rendered Markdown, HTML, screenshots it can look at, metadata, Lighthouse, console errors and more — every page loaded in real Chrome, at the same credits as the HTTP API.

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

The problem

Why an agent needs a rendering fetch

The reference fetch MCP server — the one most tutorials install first — fetches a page with a plain HTTP GET and converts the HTML it gets back. That is fine for a blog. On a React, Vue or Angular app, the HTML is an empty container and a script tag, and the agent is handed nothing while believing it read the page.

	Reference fetch server	URLpipe MCP server
How the page is loaded	HTTP GET (httpx), no JavaScript	Real headless Chrome, scripts run
Where it runs	On your machine (uvx / pip / Docker)	Hosted — nothing to install
Output	Markdown (Readability + markdownify), or raw	Markdown, rendered HTML, screenshot, metadata, Lighthouse, console, summary, keywords
Screenshots		Returned as an image the model can see
Cookie banners and ads		Removed with page_options
Cost	Free, open source	Credits from your URLpipe plan

The fetch server is the right tool when the pages are static and you want everything local and free. Reach for this one when the agent meets pages that need a browser, or when it needs to see a page, not only read it. Its source is at modelcontextprotocol/servers.

Setup

Connect your client

Create an organization token under MCP access in your dashboard, then give your client the URL and the header.

Three values are the whole setup: transport streamable HTTP, URL https://urlpipe.dev/mcp, and an Authorization: Bearer YOUR_TOKEN header. There is no OAuth flow and no local process. The token is not your project API key — see tokens and scopes below.

Claude Code

claude mcp add --transport http urlpipe https://urlpipe.dev/mcp \
  --header "Authorization: Bearer YOUR_TOKEN"

Cursor

~/.cursor/mcp.json (or.cursor/mcp.json in a project)

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

VS Code

{
  "inputs": [
    {
      "type": "promptString",
      "id": "urlpipe-token",
      "description": "URLpipe MCP token",
      "password": true
    }
  ],
  "servers": {
    "urlpipe": {
      "type": "http",
      "url": "https://urlpipe.dev/mcp",
      "headers": {
        "Authorization": "Bearer ${input:urlpipe-token}"
      }
    }
  }
}

Windsurf

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

Claude Desktop

Claude Desktop's config file starts local servers, so a remote server with a bearer header goes through the mcp-remote bridge, which needs Node.js. The header's space lives in the environment variable because some clients don't escape spaces in arguments:

{
  "mcpServers": {
    "urlpipe": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://urlpipe.dev/mcp",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": {
        "AUTH_HEADER": "Bearer YOUR_TOKEN"
      }
    }
  }
}

Any other client that speaks streamable HTTP takes the generic shape in the MCP docs. Keep the token out of files you commit — the examples above read it from an environment variable or a prompt where the client supports it.

Or install it from a directory

The server is listed in the MCP directories, which set it up for you in the clients they support, and in the official MCP Registry as dev.urlpipe/mcp. Its registry entry and the setup for every client above are open source on GitHub.

Smithery Glama GitHub: URLpipe/mcp

Tools

The 14 tools

Nine are the API endpoints, with the same arguments and the same responses. Five exist only here.

Tool	What it returns	Credits
fetch_markdown	The page's main content as Markdown	1
fetch_html	The rendered HTML, after JavaScript	1
capture_screenshot	A full-page screenshot, as an image the model can see	1
capture_console_errors	Errors, warnings and uncaught exceptions the page logs	1
run_lighthouse_audit	Lighthouse scores and Core Web Vitals lab metrics	2
extract_metadata	Title, description, author, dates, image, favicon, feed	5
extract_keywords	Keywords from the page, by an AI model	15
summarize_page	A summary of the page, by an AI model	17
scrape_url	Several of the above from one page visit	sum of its operations
list_projects	Your projects and their ids — every fetch names one	0
get_usage	Credits used and left, reset date, the price list	0
get_result	The result of an earlier call, by token	0
list_requests	What a project already fetched, filterable by label	0
get_request	One request in detail: timings, options, webhook delivery	0

Tell your agent once: fetch_markdown costs 1 credit and summarize_page costs 17 credits. If the agent will read the page itself, Markdown is both cheaper and the better input; the AI tools are for when the summary or the keyword list is the thing you're producing. The server says the same to the model when it connects.

Behaviour

Async by default, even for an agent

A tool call returns a token straight away and the work continues in the background, exactly as the HTTP API does. Pass sync: true when the agent should wait and be handed the result; otherwise it collects the result with get_result. An async call also delivers to the project's webhook if one is configured, so an agent can start work your backend receives.

Every endpoint tool takes project_id and url, plus the options its endpoint takes — page_options, screenshot_options, max_age, residential, labels and idempotency_key for safe retries. Stored results are reused for free, so an agent that re-reads a page it read yesterday spends nothing.

Access

Tokens, scopes and limits

• Organization tokens. One token reaches every project in the organization, which is why each fetch names a project_id. You can narrow a token to one project.
• Read-only scope. A token can be limited to reading past results, usage and projects. It cannot fetch a page, so it cannot spend credits.
• Expiry. Give a token an end date, or delete it to revoke it at once. It is shown once and stored as a hash.
• Limits. 300 calls per 5 minutes per token — comfortably above one a second, sustained — and your plan's parallel-request limit.
• The same bill. An MCP call spends exactly what the matching endpoint spends, from the same allowance. Failed fetches and reused results are free.

Limits

What it does not do

• No interactive browsing. The agent can't click, type, log in or fill forms. Each tool loads one public URL and reports what it found.
• No crawling. It doesn't discover or follow links on its own; the agent decides which URLs to fetch.
• No OAuth sign-in. Authentication is a bearer header; clients that only support an OAuth connector need the bridge shown for Claude Desktop.
• Public pages only. Private, loopback and intranet addresses are refused.

Pricing

What it costs

Call	Credits	Free (calls/mo)	Starter (calls/mo)	Pro (calls/mo)	Scale (calls/mo)
/markdown	1 credit	1,000	20,000	55,000	175,000
/screenshot	1 credit	1,000	20,000	55,000	175,000
/meta	5 credits	200	4,000	11,000	35,000

Cache hits and failed requests cost nothing. Paid plans are never cut off: past the allowance, extra credits are $1.50 per 1,000 credits. See every plan.

Endpoints

The endpoints on this page

• Turn any URL into clean Markdown Paste a link and get the page's main content as tidy Markdown — headings, lists, links and code kept, navigation and cookie banners stripped. The format LLMs and RAG pipelines work best with. Try it free
• Screenshot any website from its URL Paste a link and get a full-page PNG of the rendered page — JavaScript executed, exactly as a real browser would draw it. Great for previews, monitoring and visual QA. Try it free
• Check a page's Open Graph tags and metadata Paste a link and get the page's metadata — title, description, author, publication date, feed and main image — cleaned into one structured object. Try it free

FAQ

Frequently asked questions

Does this MCP server render JavaScript?

Yes. Every tool that reads a page loads it in headless Chrome and lets its scripts run first, so single-page apps come back with their content — unlike the reference fetch server, which does a plain HTTP GET.

Do I need to install anything?

No. It is a remote streamable-HTTP server: give your client the URL https://urlpipe.dev/mcp and an Authorization: Bearer header. Only clients that start local servers from a config file, like Claude Desktop, need the mcp-remote bridge.

What does it cost?

The same credits as the HTTP API, from the same monthly allowance — fetch_markdown is 1 credit, capture_screenshot 1 credit, extract_metadata 5 credits. The free plan works with MCP too.

Can the agent see screenshots?

Yes. capture_screenshot returns the image as an MCP image content block, so a model that accepts images looks at the page rather than holding a base64 string. A no-key link to the image comes back beside it.

Can I stop an agent from spending credits?

Create the token with the read-only scope. It can list projects, check usage and read results that were already paid for, and it cannot fetch a page.

Why did my tool call return a token instead of a result?

Async is the default, as in the HTTP API. Pass sync: true to wait for the result, or collect it later with get_result and the token.

Connect your agent in two minutes.

Free plan, no card. Confirm your email and your API key is live — you'll be making real requests in minutes.