# MCP server

> Connect Claude, ChatGPT, Cursor, Claude Code or any MCP client to your workspace.

Orbitwrite runs a hosted [Model Context Protocol](https://modelcontextprotocol.io) server. Connect an AI client to it
and ask, in plain words, for what you want: "draft a LinkedIn post about our launch and schedule it for Thursday
morning", "what were our best posts last month?", "answer the open replies on yesterday's thread".

```text
https://mcp.orbitwrite.com/mcp
```

The agent works through the same rules as the app: your permissions, each network's limits, and your workspace's
approvals. It sees your channels by name and handle, never the credentials behind them.

## Claude and ChatGPT: sign in

No key needed.

**Claude**

1. In Claude, open **Settings → Connectors → Add custom connector**.
2. Paste `https://mcp.orbitwrite.com/mcp`.
3. Sign in to Orbitwrite, pick the workspace, and approve what Claude may do.

The connector is then available in Claude on the web, desktop and mobile.

**ChatGPT**

1. In ChatGPT, add a custom connector (in developer mode, under **Settings → Connectors**).
2. Paste `https://mcp.orbitwrite.com/mcp`.
3. Sign in to Orbitwrite when ChatGPT asks, pick the workspace and approve.

Disconnect a client any time under **Settings → MCP → Connected apps**.

## Other clients: an API key

Clients that can't sign in send an [API key](https://orbitwrite.com/docs/developers/authentication#api-keys). **Settings → MCP** shows each
snippet with your key filled in.

**Claude Code**

```bash
claude mcp add --transport http orbitwrite https://mcp.orbitwrite.com/mcp \
  --header "Authorization: Bearer $ORBITWRITE_API_KEY"
```

Adds it to the current project. Pass `--scope user` to make it available in every project.

**Cursor**

In `~/.cursor/mcp.json` (or `.cursor/mcp.json` for one project):

```json
{
  "mcpServers": {
    "orbitwrite": {
      "url": "https://mcp.orbitwrite.com/mcp",
      "headers": { "Authorization": "Bearer orbit_sk_..." }
    }
  }
}
```

Cursor picks the file up without a restart; check **Settings → MCP** for a green dot.

**VS Code**

In `.vscode/mcp.json`:

```json
{
  "servers": {
    "orbitwrite": {
      "type": "http",
      "url": "https://mcp.orbitwrite.com/mcp",
      "headers": { "Authorization": "Bearer orbit_sk_..." }
    }
  }
}
```

Keep this file out of version control, or move the header into an input variable.

**Claude Desktop**

Claude Desktop's config file takes local commands, so it reaches the hosted server through the `mcp-remote` bridge.
In `claude_desktop_config.json` (**Settings → Developer → Edit Config**):

```json
{
  "mcpServers": {
    "orbitwrite": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.orbitwrite.com/mcp", "--header", "Authorization: Bearer orbit_sk_..."]
    }
  }
}
```

Restart Claude Desktop after saving. It needs Node.js installed.

**OpenAI API**

An entry in the Responses API's `tools` array:

```json
{
  "type": "mcp",
  "server_label": "orbitwrite",
  "server_url": "https://mcp.orbitwrite.com/mcp",
  "authorization": "orbit_sk_..."
}
```

**Other**

Any client that speaks Streamable HTTP and can send a header works:

```text
URL        https://mcp.orbitwrite.com/mcp
Transport  Streamable HTTP
Auth       Authorization: Bearer orbit_sk_...
```

Clients that support OAuth can skip the key and sign in instead.

```prompt title="Try it"
Use Orbitwrite. List my connected channels, read the brand voice, then draft a short post announcing our new docs for each channel, score it, and suggest the next free time to post it. Don't schedule anything until I confirm.
```

## What an agent can do

Over a hundred tools covering channels, posts and drafts, scheduling and posting slots, media uploads, approvals,
comments, campaigns, tags and hashtag sets, the inbox and team inboxes, Auto-DM, analytics and brand voice. The
[MCP tools reference](https://orbitwrite.com/docs/developers/reference/mcp-tools) lists every one, with its inputs.

A credential only sees the tools it's allowed to use. A read-only key gets no publishing tools, so a missing tool means
a missing permission, not a missing feature. Connecting channels stays in the app, because every network's connect
flow is a browser step.

Clients that support MCP Apps, like Claude, show some results as interactive views: `suggest_post_times`, for example,
returns a slot picker.

## Limits and safety

- Each credential can make 240 tool calls a minute. An agent stuck in a loop slows itself down, not your team.
- Publishing tools hand the post to the networks and return before they answer. Agents read the outcome with
  `get_publish_status`.
- Members on plans with approvals can only schedule behind an approval, through MCP as in the app.
- Every refusal says why: a network limit, a permission the credential doesn't hold, or a post that has already
  moved on.