Connecting your assistant to Reelwire

The Reelwire MCP server speaks two transports, and which one you use depends on the client, not on what you want to do. The tools are identical either way.

Transport	Use it when	Address
Streamable HTTP	The client connects to a server over the network	`https://mcp.reelwire.io/mcp`
stdio	The client starts the process itself, on your own machine	`node .../mcp/dist/index.js --stdio`

Prefer HTTP unless the client only supports stdio: there is nothing to install, and it is always the current version.

There are also two ways to prove who you are. claude.ai and ChatGPT sign you in: you approve the connection on a Reelwire page and it makes its own key. Everything else takes a key you make and paste into its configuration.

Before you start: make the key

Connecting from claude.ai or ChatGPT? Skip this: they sign you in instead of taking a key, and the connection makes its own. See claude.ai and ChatGPT below.

Everything the assistant can do comes from this key, so make one for it rather than reusing a key some other system already holds. Making keys is for the workspace owner, or a colleague given the admin power.

Sign in to Reelwire and open Connections → API keys. The first card, API keys for Reelwire, is the one you want.
Press Create key and name it after the assistant, not after yourself: Claude, ChatGPT, Ops assistant. When you come to revoke one, the name is how you know which.
Choose when it expires: Never, a period (a day, a week, 30 or 90 days, a year) or an exact date and time in UTC. From that moment it stops working as if revoked, and its row says EXPIRED. A key for trying things out is worth giving a week.
Tick the permissions you want it to have. The picker is grouped exactly like the side menu, so "everything except publishing" is a thing you can actually see and tick. See Permissions for what each area covers.
Copy the secret. It is shown once. If you lose it, revoke the key and make another; there is no way to recover it, by design.

Start narrower than you think

A key with read-only permissions is a genuinely useful assistant: it can answer what went out, why something failed and what is scheduled. Widen it once you have watched it work for a week.

Claude

Claude Desktop and Claude Code

Both read the same kind of configuration file. Open Settings → Developer → Edit Config in Claude Desktop, or use claude mcp add in Claude Code.

{
  "mcpServers": {
    "reelwire": {
      "type": "http",
      "url": "https://mcp.reelwire.io/mcp",
      "headers": {
        "Authorization": "Bearer rw_your_key_here"
      }
    }
  }
}

Restart the client. You should see Reelwire in the tools list with more than a hundred tools; Every tool lists them.

Claude Desktop can also connect the way claude.ai does, as a connector you sign in to, with no key to paste: see claude.ai below.

In Claude Code the same thing in one line:

claude mcp add --transport http reelwire https://mcp.reelwire.io/mcp \
  --header "Authorization: Bearer rw_your_key_here"

claude.ai

claude.ai connects by signing you in to Reelwire, so there is no key to make or paste.

In claude.ai open Settings → Connectors and add a custom connector.
Give it the address https://mcp.reelwire.io/mcp and a name, Reelwire.
Press Connect. A Reelwire page, Connect an assistant, opens: sign in if you are not already, and it names the assistant and the workspace it would use.
Choose what it may do. Reading everything the workspace has is always included, exactly as a read only key would. The switch below it, Also allow it to change things, decides whether it may also configure the workspace, send data in, and make and publish posts; it is on when the assistant asked to act. Press Allow reading and acting, or Allow reading with the switch off, and you are back in claude.ai, connected. Deny sends it away with nothing.

What you allowed becomes a key of its own, listed under Connections → API keys with the assistant's name and (connected) after it. Reading gives it the same permissions as the Read only set on the keys screen; reading and acting gives it Run the whole workspace. Either way it can never create keys, set the keys for your AI services, or touch money. Reelwire also emails you and the workspace's owners to say an assistant was connected.

Its row reads Renewed by the assistant where other keys show an expiry: the connection renews itself while you use it and lapses after thirty days of not being used. Revoke there ends the connection; it stops working within ten seconds. To change what a connection may do, revoke it and connect again, choosing differently.

Who may connect

Connecting makes a key, so it needs the same right as making one by hand: the workspace owner, or a colleague given the admin power. Anybody else sees a page saying so. A connection counts as one of the workspace's keys, and a workspace whose subscription was cancelled cannot make new ones.

ChatGPT

ChatGPT connects the same way claude.ai does: by signing you in, with no key to paste. Add a custom connector (ChatGPT keeps these in its settings, and depending on your plan may ask you to switch on developer mode first), give it https://mcp.reelwire.io/mcp, choose OAuth if it asks how to authenticate, and sign in to Reelwire when the page opens. The consent page and the key it makes are exactly those described under claude.ai.

Some ChatGPT surfaces expose only search-shaped and fetch-shaped tools to the model rather than the full set. Where that is the case, reelwire_search_docs, reelwire_read_doc and the reelwire_list_* tools still work, and the ones that change things may not appear. If you need the full set, use a client that passes MCP tools through whole.

Coding agents

The agents that live in a terminal or an editor connect the same way, and they are worth naming separately because the reason to use one here is different. An assistant in a chat window answers questions about the workspace; an agent sitting in your repository can write the script that pushes events at a custom feed, and then run it and watch what arrives, without leaving the editor.

All of them take the same key from the step above, and all of them are bound by exactly what that key may do. A client that can sign in with OAuth by itself may also connect with no key in its configuration: leave the Authorization header out, and it opens the same Reelwire consent page in your browser.

Claude Code

One line, and the configuration above covers the desktop app at the same time:

claude mcp add --transport http reelwire https://mcp.reelwire.io/mcp   --header "Authorization: Bearer rw_your_key_here"

Codex

Codex keeps its MCP servers in ~/.codex/config.toml, as TOML rather than JSON:

[mcp_servers.reelwire]
url = "https://mcp.reelwire.io/mcp"

[mcp_servers.reelwire.http_headers]
Authorization = "Bearer rw_your_key_here"

On a build of Codex that only starts servers itself, give it the stdio form instead:

[mcp_servers.reelwire]
command = "node"
args = ["/path/to/reelwire/mcp/dist/index.js", "--stdio"]
env = { REELWIRE_BASE_URL = "https://app.reelwire.io", REELWIRE_API_KEY = "rw_your_key_here" }

Cursor

Cursor reads ~/.cursor/mcp.json for every project, or .cursor/mcp.json inside one. The second is the better place for a workspace key, because it travels with the repository that uses it:

{
  "mcpServers": {
    "reelwire": {
      "url": "https://mcp.reelwire.io/mcp",
      "headers": { "Authorization": "Bearer rw_your_key_here" }
    }
  }
}

Then Settings → MCP, where Reelwire should appear with its tools listed. Cursor asks before each tool call until you tell it not to, which is worth leaving on while the key can publish.

VS Code

VS Code reads .vscode/mcp.json in a workspace. Note it says servers, not mcpServers:

{
  "servers": {
    "reelwire": {
      "type": "http",
      "url": "https://mcp.reelwire.io/mcp",
      "headers": { "Authorization": "Bearer rw_your_key_here" }
    }
  }
}

Or add it from the command line:

code --add-mcp '{"name":"reelwire","type":"http","url":"https://mcp.reelwire.io/mcp","headers":{"Authorization":"Bearer rw_your_key_here"}}'

The tools appear to the agent mode of the editor's chat, not to plain completions.

A key in a repository is a key in your history

.cursor/mcp.json and .vscode/mcp.json sit inside the project, so a key pasted into either is a key somebody can commit. Put the file in .gitignore, or keep the server in the per-user configuration and leave the project file out of it. Revoking is one press under Connections → API keys if it does get out, and a key with an expiry date limits the damage even if nobody notices.

Any other client

Anything that speaks MCP can connect. The two shapes are:

Streamable HTTP, for a server somebody is running:

{
  "mcpServers": {
    "reelwire": {
      "type": "http",
      "url": "https://mcp.reelwire.io/mcp",
      "headers": { "Authorization": "Bearer rw_your_key_here" }
    }
  }
}

stdio, for a client that starts the process:

{
  "mcpServers": {
    "reelwire": {
      "command": "node",
      "args": ["/path/to/reelwire/mcp/dist/index.js", "--stdio"],
      "env": {
        "REELWIRE_BASE_URL": "https://app.reelwire.io",
        "REELWIRE_API_KEY": "rw_your_key_here"
      }
    }
  }
}

Clients known to work with one or both, besides the ones above: Windsurf, Zed, Cline, Continue, LibreChat, and anything built on the official MCP SDKs.

Running it yourself

The server is a container. If you would rather it sat inside your own network, next to your own systems:

docker run -d \
  -p 4500:4500 \
  -e REELWIRE_BASE_URL=https://app.reelwire.io \
  reelwire/mcp

It holds no key of its own. Over HTTP every client sends its own key in the Authorization header, exactly as above, and the server acts as that key for that one request, so one server serves every person who connects to it, each strictly as themselves. Signing in with OAuth is offered only by Reelwire's own server, so clients of yours send a key.

Variable	What it is
`REELWIRE_BASE_URL`	Where the Reelwire API lives
`REELWIRE_API_KEY`	For stdio only: the key of the one person whose assistant starts the process. Leave it out of a container, where it is never read
`REELWIRE_DOCS_DIR`	Where the documentation pages are. Without them the tools still work and `reelwire_search_docs` finds nothing
`REELWIRE_DOWNLOAD_DIR`	Where tools that produce a file write it. Defaults to a temporary directory
`MCP_ALLOWED_ORIGINS`	Browser origins allowed to call it, comma separated. Assistants send none and are unaffected; empty accepts no browser
`MCP_RATE_LIMIT_PER_MINUTE`	Requests per minute for one key. Defaults to 600
`PORT`	What it listens on. Defaults to 4500

GET /health says whether it is up, the version and commit it runs, and how many documentation pages it is carrying.

Checking it worked

Ask the assistant:

Who am I on Reelwire, and what can you do?

It should call reelwire_whoami and answer with the workspace name and the permissions the key holds. That one question tells you three things at once: the connection works, the key is valid, and the permissions are what you meant to grant.

Then:

What is scheduled to go out this week?

which reaches reelwire_calendar. And if you ever need to tell us which Reelwire you are talking to, ask "which version of Reelwire is this?": reelwire_version answers with the version and commit of both the MCP server and the API behind it.

When it does not work

The assistant does not see any Reelwire tools. The client did not connect. Restart it fully, not just the conversation. Check the URL ends in /mcp.

Everything is refused with "this key may not..." The key is valid and too narrow. The refusal names the permission; go back to Connections → API keys, press Permissions on the key and tick it. For a connection made by signing in, revoke it and connect again, allowing it to act.

"The key was not accepted" on every call. The key is wrong, revoked, expired, or was pasted with a trailing space. Keys start rw_. Make a fresh one rather than hunting for the typo. A connection made by signing in reconnects by itself; if it does not, connect again.

"That is a dashboard session, not an API key." Something handed the assistant the token your browser signs in with, which starts rws_. Make an API key instead.

"Reelwire no longer knows this assistant." The connection registered itself long ago and that registration is gone, because it was never used or sat unused for months. Remove Reelwire from the assistant's connectors, add it again, and connect once more.

"More than 600 requests this minute" or "Too many failed sign-ins". One key may make 600 requests a minute, and an address whose keys have failed 30 times in a minute is refused for the rest of it. Wait a minute; if it keeps happening, the assistant is looping, and telling it to stop and explain is the fix.

Tools appear but time out. The client cannot reach the server. If you are running it yourself, check the container is up and the port is published.

A render never finishes. It takes about a minute, longer when the machines are busy. In Claude and ChatGPT the player under the answer follows it by itself. Elsewhere the assistant should leave ten to fifteen seconds between polls of reelwire_export_status; some will poll harder than that and give up. Tell it to wait.

Before you start: make the key​

Claude​

Claude Desktop and Claude Code​

claude.ai​

ChatGPT​

Coding agents​

Claude Code​

Codex​

Cursor​

VS Code​

Any other client​

Running it yourself​

Checking it worked​

When it does not work​