MCP server

URLpipe speaks the Model Context Protocol, so an AI agent can fetch and read pages directly instead of you writing the HTTP calls. Point any MCP client at one endpoint and it can turn a URL into Markdown, a screenshot, metadata or a Lighthouse audit on its own.

The tools are the endpoints documented in this site — same arguments, same responses, same credits. There is nothing new to learn: if you know POST /markdown, you know fetch_markdown.

Create a token

MCP uses its own credential: an organization token, created in MCP access under your organization. It is not the project API key the HTTP endpoints take — a project key names one project, and an agent works across all of them.

You choose what a token may do when you create it:

• Fetch pages and read results — everything. This is what an agent normally needs.
• Read past results only — can list projects, read usage and retrieve results somebody already paid for, but cannot fetch a page. A token that physically cannot spend your credits.

A token is shown once and stored as a hash, so copy it when you create it. Deleting it revokes it immediately. You can also narrow a token to a single project, or give it an expiry date.

Connect a client

This is a remote server, so there is nothing to install and no command to run. A client needs three things, and they are the whole of the setup:

• Transport — streamable HTTP. The server answers each message with a single JSON response; it opens no SSE stream and keeps no session.
• URL — https://urlpipe.dev/mcp
• Authentication — an Authorization: Bearer YOUR_TOKEN header, the same one every URLpipe request uses. There is no OAuth flow to complete: set the header and the client is connected.

How you register a server differs by client — some take these values in a form, some in a command, and most keep them in a JSON file of this shape:

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

The tools

9 tools are the API endpoints. Each takes the same arguments its endpoint does, and answers with the same body.

5 more exist only here, because an organization token reaches more than one project and the HTTP API's credential does not:

Arguments

Every endpoint tool takes project_id and url, plus the optional arguments its endpoint accepts.

Async is still the default

As with the HTTP API, a call returns a token straight away and the work continues in the background. Pass sync: true when you want the agent to 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, and a sync call does not — the same rule, and the same reason, as over HTTP: a sync caller already has the answer in hand. See async & sync modes.

What it costs

An MCP call spends exactly what the matching endpoint spends, from the same monthly allowance — there is no separate meter and no surcharge for using an agent. Reused results are free, and a failed fetch is never billed. The credits page has the full table; get_usage returns your live numbers and the same prices, so an agent can check what a run will cost before it starts.

Errors and limits

A refused call comes back as a tool error whose body is the API's own error object — the same error code and message an HTTP caller gets, so quota_exceeded, concurrency_limit and invalid_url mean what the errors page says they mean.

The endpoint is rate limited per token, at a ceiling comfortably above one call per second sustained. Your plan's parallel-request limit applies here too.