Give Claude and Cursor Web Access With an MCP Server

An MCP server gives an AI app new tools. Add Grabber's remote server, https://mcp.grabber.sh, to Cursor, Claude Code, Claude Desktop, VS Code or Windsurf, and your agent gets a fetch_page tool that loads any public URL and returns it as Markdown, plus a free check_balance tool. Setup is one URL and one header in a config file. There is nothing to install, and a page costs $0.001.

What MCP is

The Model Context Protocol is an open standard, introduced by Anthropic in November 2024, for connecting AI applications to tools and data. The app, such as Claude, Cursor or VS Code, is the client. A server publishes a list of tools, each with a name, a description and the arguments it takes. When the model decides a tool would help, the client calls it on the server and hands the result back to the model.

Servers come in two kinds:

Grabber's server is remote. Every client connects to the same URL and sends your API key as Authorization: Bearer gsh_....

Why give a coding agent the web?

A model knows what was in its training data, up to a cutoff date. Anything newer, or anything it never saw, it has to guess. Web access turns guessing into reading:

• Current docs. "Read the migration guide for version 5 before you change the config" gets you code for the version you use, not the one the model remembers.
• The actual issue. Paste the link to a GitHub issue or a changelog and the agent reads it, instead of you copying it into the chat.
• Research. Compare three libraries from their docs, or summarize a section of a spec.
• Your own public pages. Check that the pricing page shows the new price after a deploy.

The agent gets Markdown instead of HTML, so a docs page costs far fewer tokens than its markup would, and more of the context window is left for your code.

Set it up

First create an API key in the dashboard (how keys work). Keys start with gsh_ and are shown only once, so copy yours when you create it. New accounts get $1 of free credit, about 1,000 pages. Then add the server to your client.

Cursor

Put this in ~/.cursor/mcp.json to use it in every project, or in .cursor/mcp.json inside one project:

{
  "mcpServers": {
    "grabber": {
      "url": "https://mcp.grabber.sh",
      "headers": {
        "Authorization": "Bearer gsh_your_api_key"
      }
    }
  }
}

The server and its two tools then show up in Cursor's MCP settings. If they do not, reload the window.

Claude Code

One command in your terminal:

claude mcp add --transport http grabber https://mcp.grabber.sh \
  --header "Authorization: Bearer gsh_your_api_key"

By default the server is added for the current project. Add --scope user to have it in every project, and run claude mcp list to check the connection.

VS Code

Add .vscode/mcp.json to your project:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "grabber-key",
      "description": "Grabber API key",
      "password": true
    }
  ],
  "servers": {
    "grabber": {
      "type": "http",
      "url": "https://mcp.grabber.sh",
      "headers": {
        "Authorization": "Bearer ${input:grabber-key}"
      }
    }
  }
}

VS Code asks for the key the first time the server starts and stores it for you, so the key never lands in the file and the file is safe to commit.

Windsurf

Windsurf reads ~/.codeium/windsurf/mcp_config.json, and calls the address serverUrl:

{
  "mcpServers": {
    "grabber": {
      "serverUrl": "https://mcp.grabber.sh",
      "headers": {
        "Authorization": "Bearer gsh_your_api_key"
      }
    }
  }
}

Claude Desktop

Claude Desktop's config file starts local servers, so it reaches a remote one through mcp-remote, a small bridge that runs with npx and needs Node.js. Edit claude_desktop_config.json (Settings, then Developer, then Edit Config) and restart the app:

{
  "mcpServers": {
    "grabber": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.grabber.sh",
        "--header",
        "Authorization:${GRABBER_AUTH}"
      ],
      "env": {
        "GRABBER_AUTH": "Bearer gsh_your_api_key"
      }
    }
  }
}

The header value comes from the GRABBER_AUTH variable, which keeps the space in "Bearer gsh_..." intact on every operating system.

The two tools

format defaults to markdown; the other choices are html, text and links. max_chars cuts the content after that many characters, up to 100,000, so one long page cannot fill the context window. A page that was cut says so at the end, and costs the same as a whole one.

Everything else works like the API: the same prices, the same limit of 60 requests a minute per key (shared with your API calls), and every call shows up in the dashboard's request log with its cost.

Prompts that work

Agents call a tool when the task clearly needs it, so be explicit:

• "Read https://nextjs.org/docs/app/guides/upgrading/version-16 and list the changes that affect this project."
• "Fetch the README at https://github.com/modelcontextprotocol/typescript-sdk and set up a client the way it shows."
• "Compare the pricing pages of these three services in a table."
• "How much Grabber credit do I have left?" This one calls check_balance, which is free.

For a project you work on every day, put the rule in your agent's instructions (AGENTS.md, CLAUDE.md or a Cursor rule), so you do not have to repeat it:

When you need a web page, call the grabber fetch_page tool instead of guessing.
Use js_render only if the page comes back empty or asks for JavaScript.
Pass max_chars: 20000 unless you need the whole page.

Cost, keys and safety

• Cost. Each fetch_page call is one request: $0.001, or $0.005 rendered. An agent that reads 50 pages during a task spends 5 cents. Failed fetches and check_balance are free.
• One key per machine. Create a separate key for each laptop or CI runner, so you can delete one in the dashboard without breaking the others.
• Keep keys out of git. ~/.cursor/mcp.json lives in your home directory, but a project's .cursor/mcp.json is easy to commit by accident. Use VS Code's input prompt, or keep keys out of project files.
• Treat pages as untrusted input. A fetched page is text written by someone else, and it can contain instructions aimed at your agent. fetch_page only reads, but your agent may also have tools that write files or run commands, so keep approval prompts on for those.

Troubleshooting

FAQ

Do I need to install anything?

Not for Cursor, Claude Code, VS Code or Windsurf: they connect to the URL directly. Claude Desktop needs Node.js for the mcp-remote bridge.

Is there a local version of the server?

No. The server is remote only, so there is nothing to install or keep up to date.

Does it work with other MCP clients?

Any client that can connect to a remote server over Streamable HTTP and send a custom header can use it. Clients that only start local servers can go through mcp-remote, as Claude Desktop does above.

Can my agent use the REST API instead?

Yes, if it can make HTTP requests. The docs and the OpenAPI file describe the API. MCP is simply the easiest way to give a chat or coding agent the tool.