MCP connector · one conversation

One conversation, a finished trailer.

Start with a premise, a note, or a screenplay you already have, in Claude or any other assistant that can write. The same conversation carves the story, writes the pages, voices a table read, and renders the trailer. ChatGPT on web reads and writes the same work.

Add it in one step

Paste one address into your assistant.

No account yet? Create your account first: you land back on this box signed in, and the sign-in your assistant opens below connects the address to it.
In Claude: In Claude on web or Desktop, open Customize → Connectors and choose Add custom connector.
Paste the connector URL. Leave the OAuth client choice on "Register automatically": Sleeper Hit Studio registers the client dynamically. Sign in, then authorize.

Connector URL

https://sleeperhit.studio/mcp

Connecting from a terminal or an editor? Pick your client below.

One conversation, start to finish

You: Turn this premise into a trailer: a lighthouse keeper starts receiving letters written in a hand she buried twenty years ago.

Series Bible
Act 1 draft
Voiced table read
2:14 trailer

Sleeper Hit: The trailer is rendered and ready to watch. Want the pitch package next?

An example exchange. Sleeper Hit pauses for your approval before anything is generated or published.

Every client

Pick your client.

Same connector, same sign-in, whichever assistant or terminal you already work in.

Claude

The full authenticated connector. Runs in: claude.ai on web, Desktop, and mobile; Claude Code in the terminal.

In Claude on web or Desktop, open Customize → Connectors and choose Add custom connector.
2
Paste the connector URL. Leave the OAuth client choice on "Register automatically": Sleeper Hit Studio registers the client dynamically. Sign in, then authorize.
Connector URL
```
https://sleeperhit.studio/mcp
```

In Claude Code, add the server:

Terminal command

claude mcp add --transport http sleeperhit https://sleeperhit.studio/mcp

Then run /mcp in a session, choose sleeperhit, and pick Authenticate.

ChatGPT

The restricted ChatGPT profile: 82 tools that fetch and read sources, the Series Bible, coverage, drafts and table reads, pitch-deck and trailer videos, and shows — and they write too (story, source, artifact, publishing in the grant), so no part of it is read-only. Every paid step is priced first, and Studio Credits are bought on sleeperhit.studio, never in ChatGPT. Runs in: ChatGPT on web (developer mode / custom apps); desktop and mobile are not supported for custom connectors today.

In ChatGPT on web, open the plugins/connector screen (chatgpt.com/plugins) and choose Add custom MCP server.
2
Point it at the ChatGPT profile of the connector, choose OAuth as the auth, and let the sign-in finish in the browser before saving.
Connector URL
```
https://sleeperhit.studio/mcp/chatgpt
```

Team and workspace plans

Where the workspace uses developer mode / custom apps instead, create a custom app on the same URL, run Scan Tools so the catalog loads, and ask an admin to publish it (only Admins and Owners can publish).

Signing in

The first call opens the Sleeper Hit Studio sign-in. ChatGPT keeps a long-lived token: revoke it any time from Profile → connected apps, and in the Sleeper Hit Studio account under connected applications.

Good to know

Web only for custom connectors; mobile and desktop apps do not add custom connectors today.
The connection carries the profile's write and publish scopes, so it can start a project, change a script and approve a plan. Which ChatGPT plans offer custom connectors is ChatGPT's own gate — Sleeper Hit narrows nothing by plan.
The restricted profile is the intended path: fewer tools, clearer behavior. The full connector at /mcp also works but is not what ChatGPT was scoped for.

Full ChatGPT guide on the docs site

Codex CLI

The full authenticated connector. Runs in: Codex CLI on macOS, Linux, and Windows.

If you're an agent reading this

You cannot complete the app's browser OAuth from inside a chat or a sandboxed shell: the browser cannot reach your sandbox's callback, so your user approves and no token arrives. Do not run that browser login yourself, and do not retry it. A device sign-in needs no callback and does finish inside a sandbox: sleeperhit login --no-browser prints a code and a URL for your user to approve in their own browser, then saves the key in ~/.config/sleeperhit/credentials.json — export it as SLEEPERHIT_API_KEY for the bearer-token step below. With no CLI to run, the same sign-in is two keyless calls you make yourself: POST https://sleeperhit.studio/api/auth/device/code with {"client_id":"sleeperhit-cli","scope":"story:read credits:read artifact:read story:write source:write source:read"} answers a user_code and a verification_uri for your user, and polling POST https://sleeperhit.studio/api/v1/device/credential with its device_code every interval seconds returns the key. Name the scopes you will use in scope, as that call does: a request that sends only client_id is approved as a read-only key (every read, no write), so the first create is refused insufficient_scope. That scope names the calls that read, create and generate, and spends nothing, so the calls that finish or publish are refused on it: refine, finalize, sharing a table read, casting a voice or a portrait and the other finish calls need artifact:publish, and a show's setup, its episodes and its releases need publishing:read, publishing:write and publishing:publish. Name every scope your journey will reach in the same scope string — the approval page lists each one before your user approves, and GET /api/v1/capabilities names them all. A sandbox cannot reconnect a browser OAuth connector or open the Developers page, so the way back from that refusal is a NEW device sign-in naming the missing scope, never a retry of the call that was refused: GET /api/v1/account/credential reads back what the key you hold carries. Otherwise ask your user to sign in from their app. They run codex mcp login sleeperhit in their own terminal, outside the agent sandbox, approve in the browser, then start a new Codex session so the tools load. Never ask them to paste an API key into the chat.

1
Add the server, then sign in. The first command opens Sleeper Hit in your browser. Sign in with Google or email, approve, then choose Return to Codex. Once you have approved Codex, signing in again skips the approval.
Terminal commands
```
codex mcp add sleeperhit --url https://sleeperhit.studio/mcp
codex mcp login sleeperhit
```
2
Working in a container, a VM, or anywhere a browser cannot hand its loopback callback back to the CLI? Add --no-browser, open the printed URL yourself, approve, then copy the link the approval page shows and paste it into Codex.
Terminal command
```
codex mcp login sleeperhit --no-browser
```
3
Running Codex in a sandbox that cannot take a browser sign-in at all? Create an API key in Dashboard → Developers, export it, and add the server with the key as its bearer token. No browser is involved.
Terminal commands
```
export SLEEPERHIT_API_KEY=sh_...
codex mcp add sleeperhit --url https://sleeperhit.studio/mcp --bearer-token-env-var SLEEPERHIT_API_KEY
```
4
Or set it directly in the Codex config file — same URL, no commands:
Config file · ~/.codex/config.toml
```
[mcp_servers.sleeperhit]
url = "https://sleeperhit.studio/mcp"
```

Cursor

The full authenticated connector. Runs in: Cursor editor (project or global MCP config); cursor-agent CLI reads the same files.

1
Add a server entry to .cursor/mcp.json in the project (or ~/.cursor/mcp.json for every project). A remote server needs only url; the transport is inferred.
Config file · .cursor/mcp.json
```
{
  "mcpServers": {
    "sleeper-hit-studio": {
      "url": "https://sleeperhit.studio/mcp"
    }
  }
}
```
Cursor offers to sign in when the server first challenges; approve the Sleeper Hit Studio authorization in the browser.
3
In the cursor-agent terminal tool, after the same mcp.json entry, authenticate it with:
Terminal command
```
cursor-agent mcp login sleeper-hit-studio
```

VS Code

The full authenticated connector, through GitHub Copilot agent mode. Runs in: VS Code with GitHub Copilot (agent mode), Desktop.

1
Either run "MCP: Add Server" from the Command Palette (choose HTTP, paste the URL), or write the file yourself. A remote server is "type": "http" plus url:
Config file · .vscode/mcp.json
```
{
  "servers": {
    "sleeperhit": {
      "type": "http",
      "url": "https://sleeperhit.studio/mcp"
    }
  }
}
```
In agent mode, open the MCP Servers section (or the MCP SERVERS view) and start the server; the first call opens the Sleeper Hit Studio sign-in.

Windsurf

The full authenticated connector. Runs in: Windsurf editor.

1
Open MCP settings and add the remote server by URL. The editor reads mcp_config.json; the remote key is serverUrl (its docs also accept url):
Config file · mcp_config.json
```
{
  "mcpServers": {
    "sleeper-hit-studio": {
      "serverUrl": "https://sleeperhit.studio/mcp"
    }
  }
}
```
Save, then hit refresh in the MCP menu; sign in to Sleeper Hit Studio when prompted.

Gemini CLI

The full authenticated connector. Runs in: Gemini CLI in the terminal.

Add the server with the http transport:

Terminal command

gemini mcp add --transport http sleeperhit https://sleeperhit.studio/mcp

2
Or write it into .gemini/settings.json (project) or ~/.gemini/settings.json — a remote Streamable HTTP server is httpUrl:
Config file · .gemini/settings.json
```
{
  "mcpServers": {
    "sleeperhit": {
      "httpUrl": "https://sleeperhit.studio/mcp"
    }
  }
}
```
Authorize with /mcp auth in a session (or gemini mcp equivalents); check status with gemini mcp list.

OpenCode

The full authenticated connector. Runs in: OpenCode in the terminal.

1
Add the server to opencode.json (project) or ~/.config/opencode/opencode.json. A remote server is type: "remote"; OpenCode handles the sign-in on its own:
Config file · opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sleeperhit": {
      "type": "remote",
      "url": "https://sleeperhit.studio/mcp"
    }
  }
}
```
2
Sign in. OpenCode asks the first time a tool is used; to sign in up front, run:
Terminal command
```
opencode mcp auth sleeperhit
```

Running OpenCode where a browser sign-in cannot finish? Use an API key from Dashboard → Developers instead, and turn the sign-in off for this server:

Config file · opencode.json

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "sleeperhit": {
      "type": "remote",
      "url": "https://sleeperhit.studio/mcp",
      "oauth": false,
      "headers": { "Authorization": "Bearer {env:SLEEPERHIT_API_KEY}" }
    }
  }
}

Any other client

The full authenticated connector. Runs in: Any MCP client that speaks Streamable HTTP and OAuth 2.1.

1
Point the client at the connector URL with the Streamable HTTP transport:
Connector URL
```
https://sleeperhit.studio/mcp
```
Choose the OAuth sign-in. The server advertises its metadata and registers clients dynamically (DCR) with PKCE (S256), so there is normally nothing to pre-register; the first call opens the Sleeper Hit Studio sign-in.

In a sandbox, a container or on another computer?

The browser sign-in cannot finish there: your browser cannot reach the sandbox's callback, so you would approve and no token would arrive. A device sign-in needs no callback and does finish inside a sandbox — run sleeperhit login --no-browser in the CLI and it prints a code and a URL; approve them in your own browser and it saves the key itself while it keeps running.

Prefer an API key, or nobody can approve a page? Make one instead. You need an account for it: the box above makes one and lands you back there signed in. Then make the key in Developers → API Keys, send it as the bearer token, keep it in SLEEPERHIT_API_KEY, and check it with whoami.

Key setup, step by step Full MCP guide API quickstart