Connecting AI tools

Grilled Cheese speaks the Model Context Protocol (MCP), the open standard AI assistants use to work with outside services. Connect Claude, ChatGPT, or any other MCP-capable tool, and it can read your timeline, post, follow, react and edit themes as you. Tools that accept a pasted key use one you mint and can revoke at any time; tools that speak MCP’s OAuth flow, like ChatGPT, connect through a consent screen instead, with nothing to copy.

What connecting actually means

An MCP client sees Grilled Cheese as a set of named tools: read the timeline, create a post, follow someone, edit a theme. The AI decides when to call them; your key decides what it is allowed to do. A key acts as you, on the identities you name when you create it, and never gets powers your own account does not have.

Reading is included with every account. Writing (posting, following, reacting, editing themes) is part of Grilled Cheese Premium.

Creating a key

Keys live in Settings > Developer, on the web app at https://grilledcheese.app/settings/developer or in the app under Settings.

Choose a name that says where the key will live ("Laptop assistant", "Home server").
Pick the identities the key may act as. A key with several identities must say which one it is acting as on every write, so most keys name exactly one.
Pick its scopes. Read scopes are open to every account; write scopes need an active Premium subscription.
Copy the key when it is shown. It is shown once: only a fingerprint is stored, so nothing can display it again. Losing it means minting a new one.

There is a ceiling on how many keys an account can hold at once, and Premium does not raise it: revoke a key to make room for another. Keys also expire on their own after 90 days, so a forgotten key does not stay live forever.

Scopes

A scope is a permission the key holds. A tool call outside the key’s scopes is refused, every time, no matter who owns the key.

Scope What it permits Tools

Scope	What it permits	Tools
`posts:read`	Read timelines, posts, threads and search	`get_timeline`, `get_post`, `get_thread`, `search_posts`
`follows:read`	Read who you follow and who follows you	(API only, no tool yet)
`reactions:read`	Read your reactions	(API only, no tool yet)
`themes:read`	Read your themes	`list_themes`
`identity:read`	Read your profile	(API only, no tool yet)
`posts:write`	Create posts, and delete posts the key itself made	`create_post`, `delete_post`
`follows:write`	Follow and unfollow	`follow`, `unfollow`
`reactions:write`	React, and remove reactions the key itself made	`react`, `unreact`
`themes:write`	Create and edit your themes	`create_theme`, `update_theme`

posts:read

Read timelines, posts, threads and search

get_timeline, get_post, get_thread, search_posts

follows:read

Read who you follow and who follows you

(API only, no tool yet)

reactions:read

Read your reactions

(API only, no tool yet)

themes:read

Read your themes

list_themes

identity:read

Read your profile

(API only, no tool yet)

posts:write

Create posts, and delete posts the key itself made

create_post, delete_post

follows:write

Follow and unfollow

follow, unfollow

reactions:write

React, and remove reactions the key itself made

react, unreact

themes:write

Create and edit your themes

create_theme, update_theme

The :write scopes are the Premium boundary. A free account can mint read keys and feel the whole thing working; posting, following, reacting and theme editing on your behalf need a live subscription. The check happens on every call, not just when the key is created: if the subscription lapses, the key’s writes stop working on the next request, and resume when it is renewed.

Connecting a client

Direct (Streamable HTTP)

Most current MCP clients, including Claude Code and newer Claude Desktop builds, connect straight to the hosted endpoint:

https://api.grilledcheese.app/mcp

with the key as a bearer token. For Claude Code, one line:

claude mcp add --transport http grilledcheese https://api.grilledcheese.app/mcp --header "Authorization: Bearer <key>"

Through the stdio bridge

Clients that can only launch a local process use the bridge package, @grilledcheese/mcp. It runs on your machine, holds the key locally, and relays each request to the endpoint above; the key never appears in a shared config service.

For Claude Desktop, add to claude_desktop_config.json (Settings > Developer > Edit Config):

{
  "mcpServers": {
    "grilledcheese": {
      "command": "npx",
      "args": ["-y", "@grilledcheese/mcp"],
      "env": { "GRILLEDCHEESE_KEY": "<key>" }
    }
  }
}

For Claude Code, the stdio equivalent is:

claude mcp add grilledcheese --env GRILLEDCHEESE_KEY=<key> -- npx -y @grilledcheese/mcp

Any other stdio client should be configured to spawn npx -y @grilledcheese/mcp --key <key>. A key with more than one identity passes --identity to say which one it acts as.

ChatGPT and other OAuth clients

ChatGPT’s custom connectors do not accept a pasted key. They require the MCP OAuth flow, and Grilled Cheese speaks it. No key is involved: you approve the connection in your browser, signed in as yourself, and you can see exactly what is being granted before anything is.

To connect ChatGPT:

In ChatGPT, open Settings > Connectors and add a custom connector with the server URL:
```
https://api.grilledcheese.app/mcp
```
ChatGPT discovers that Grilled Cheese supports OAuth and opens a browser window on the Grilled Cheese sign-in page. Sign in if you are not already.
The consent screen shows the connector’s name, where you will be sent back to, and a picker for identities and scopes, exactly like creating a key. Read scopes are preselected; write scopes need Grilled Cheese Premium, the same boundary keys have.
Approve, and ChatGPT finishes the connection on its own.

A connection made this way renews itself quietly while it is in use, and expires on its own after 90 days without use. The same rules as keys apply on every call: the connection is never more powerful than you, write access checks your subscription each time, and everything it does is attributed in the audit trail.

Approving the same connector again replaces the older connection, so a re-connect never leaves a second live grant behind. If you believe a connection is misused, remove the connector in ChatGPT and contact [email protected]; staff can revoke a connection immediately, which cuts off its tokens on their very next call.

The consent screen also warns when a connector asks to be sent back to an address on your own computer. That is normal for desktop tools such as Claude Code, and worth a second look for anything else.

Revoking a key

Revoke from the same Settings > Developer screen: each key shows its scopes, identities, creation date and expiry, with a revoke button beside it. Revocation takes effect immediately, on the key’s very next call. Revoke a key the moment you stop using the tool that held it, or suspect it leaked.

Safety notes

A key is never more powerful than you. It is capped at ordinary user powers even if you are staff, and everything it does lands in the same audit trail as your own actions, attributed to the key.
Some things are simply off the protocol. Chat and direct messages, your inner circle, account recovery, payments and moderation can never be reached by any key, with any scope.
Destructive tools announce themselves. Tools that delete something are flagged, so well-behaved clients ask you before calling them.
Treat the key like a password. Anyone holding it can act as the identities it names, within its scopes, until it expires or you revoke it. Prefer the environment variable forms above over pasting keys into command lines, and never commit a key to a repository.

Developer settings, where keys are created and revoked
Grilled Cheese Premium, which unlocks the write scopes

Questions or a stuck connection go to [email protected].