Using a Remote MCP Server (No Local Install)

Most MCP setup guides start with npx. That works if the client can spawn a local process and your machine has Node.js on its PATH. It falls apart the moment the client is a hosted app instead of a desktop one: ChatGPT and Claude's web Connectors cannot launch a subprocess on your laptop, so a local stdio server is not an option. A remote MCP server is just a server that speaks MCP over HTTP at a fixed URL, so any client that can make a request can use it. No install, no PATH to fix, no Node version to match.

Rendex runs one at mcp.rendex.dev. This guide covers what makes a remote MCP server different from a local one, when to reach for each, and the two ways to connect: with your own API key, or with OAuth and no key at all.

Local stdio vs. remote MCP servers

A local server is a subprocess your client owns. The client runs a command (npx @copperline/rendex-mcp, for example), passes an API key through an environment variable, and talks to it over stdin/stdout. Every machine that wants the tools needs the package installed, and the key lives in a local config file.

A remote server skips the subprocess entirely. The client sends JSON-RPC requests over HTTP to a single URL and gets responses back the same way (the MCP spec calls this the Streamable HTTP transport). There is nothing to publish, version, or keep updated on the client side. The tradeoff runs the other way too: a remote server needs its own auth story, since it cannot rely on the environment variable trick a local subprocess gets for free.

Prerequisites

A Rendex account. The free tier includes 100 renders per month with no credit card.
An MCP client that supports remote HTTP servers: Claude Desktop, Claude's web Connectors, and ChatGPT Connectors all do. Cursor and Windsurf currently only support the local stdio method, so use the local npx config there instead.

Step 1: Connect with an API key

The fastest path if your client lets you set a custom header. Point it at https://mcp.rendex.dev/mcp and pass your key as a bearer token. This is the same config shape Claude Desktop, and most other HTTP-capable clients, expect:

mcp.json

{
  "mcpServers": {
    "rendex": {
      "url": "https://mcp.rendex.dev/mcp",
      "headers": {
        "Authorization": "Bearer rdx_YOUR_KEY"
      }
    }
  }
}

Get rdx_YOUR_KEY from the Rendex dashboardafter signing in. Every call made through this connection bills against that key's plan and credit pool, the same as calling the REST API directly.

Step 2: Or connect with OAuth, no key at all

Clients built for the connector model (ChatGPT, Claude) skip the key entirely. mcp.rendex.devis fronted by OAuth 2.1, so you add the server by URL, authorize once with your Rendex email, and every call from that point runs under your own account without a secret ever touching the client's config:

In ChatGPT: Settings → Connectors → Create (enable Developer mode under Advanced if you do not see it). In Claude: Settings → Connectors → Add custom connector.
Name it Rendex and paste https://mcp.rendex.dev/mcp as the server URL.
Set authentication to OAuth and confirm. You will be prompted to sign in with your Rendex email using a one-time code.
Once authorized, ask the agent to use it: for example, "Use Rendex to screenshot example.com."

Because each person authenticates as themselves, a team can share one connector configuration without sharing a key: renders bill to whoever signed in, not to a single shared credential.

Step 3: Verify it is live, no client required

Because the server just answers HTTP requests, you can check it is up and see every tool it exposes from a terminal, before wiring up any client. Discovery calls like tools/list do not touch the Rendex API and carry no secrets, so the remote server answers them without a key:

list-tools.sh

curl https://mcp.rendex.dev/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

A working connection returns all 13 registered tools: five rendering tools (rendex_screenshot, rendex_render_link, rendex_extract, render_artifact, rendex_account) and the eight Rendex Watch tools for website-change monitoring. Calling a tool for real (tools/call) is the one method that does require a key or an authorized OAuth token, since that is the step that actually spends a render credit.

Step 4: Use it

Once connected, describe what you want in plain language. The agent maps it to a tool call and returns the result inline:

Screenshot northwindstatus.io and tell me if everything is green.

Extract the article text from https://example.com/blog/post-title and summarize it.

Render this HTML as a PDF and give me the download link:
<html>...</html>

Rendex connector calling rendex_screenshot over a remote MCP server via OAuth, no key pasted, returning a status dashboard — Connected once via OAuth, no key pasted anywhere in this chat

The same tools work no matter which connection method you used. A client that connected with an API key and one that connected with OAuth both get identical tool access; only the auth path and the credit pool they bill to differ.

Troubleshooting

401 or an OAuth prompt on every call. For the API key method, confirm the header is exactly Authorization: Bearer rdx_YOUR_KEY, including the space after "Bearer". For the OAuth method, the authorization can expire or get revoked; remove the connector and add it again to re-trigger the sign-in.

Connector shows no tools after authorizing. Some clients cache the tool list from the first connection attempt. Look for a refresh action in the connector settings, or remove and re-add the connector.

Client only supports local servers. If your client is Cursor, Windsurf, or another editor-first tool without remote HTTP support yet, use the local npx @copperline/rendex-mcp config from the MCP docs instead. The tool names and parameters are identical either way.

curl returns 406 Not Acceptable. The Streamable HTTP transport requires the Accept header to list both application/json and text/event-stream. Missing either one gets rejected before the request reaches a tool.

Next steps

The MCP docs cover the full parameter reference for every tool, including async capture, cookie and header injection for authenticated pages, and the Rendex Watch tools for change monitoring. If your client only supports a local process today, the Claude Desktop MCP setup guide walks through both the remote and local config side by side. And if you are weighing a hosted rendering API against running your own Puppeteer or Playwright fleet for an agent pipeline, the screenshot API for AI agents comparison breaks down the tradeoffs. Screenshots are only one of the tools this server exposes: once it's connected, an agent can also hand back a branded document instead of a picture. See AI agent PDF generation via MCP for the render_artifact tool.

To try it without connecting any client at all, run a capture through the free screenshot tool. When you are ready to wire it into an agent, get a free API key (100 renders/month, no credit card) and add the config block from Step 1, or connect via OAuth with no key to manage.