---
title: Connect your AI tool
description: Step-by-step MCP setup for Claude Code, Claude Desktop, Cursor, VS Code, Gemini CLI, Codex, Windsurf, Zed, Kimi CLI, OpenClaw, Hermes and any other MCP client.
seo_title: "Connect Claude, ChatGPT or Cursor (MCP) — Schedule & Chill"
published: 2026-08-03
updated: 2026-09-14
---

Schedule & Chill is a **remote MCP server**. Point your AI tool at one URL and it can
schedule posts, upload video from your machine, and read your queue.

## Start here: connect with a link

Most people should use this. Paste this URL into your AI tool:

```
https://schedulenchill.com/mcp-oauth
```

There is no key to create and nothing to paste into a config file. Your tool sends you to a
Schedule & Chill consent screen that names the tool and lists what it is asking for. Approve
it once and the tool holds its own token from then on.

It works anywhere there is an **Add connector** or **Add MCP server** button — Claude,
ChatGPT, Cursor, VS Code, Zapier. Each tool is approved separately, revoking one leaves the
others alone, and your password is never shared.

## Or connect with an API key

Some clients want a static header instead, and scripts usually do. That endpoint is:

```
https://schedulenchill.com/mcp
```

```
Authorization: Bearer YOUR_API_KEY
```

Create a key under **Settings → API Keys**. Use a token with `*` abilities (the default) —
a restricted token will 401 on media uploads.

Both endpoints expose exactly the same 22 tools, 4 resources and 2 prompts. Nothing is
missing from either one; only the sign-in differs.

## One click for Cursor and VS Code

Open **Connect AI Tool** in your account, create a key, and press **Add to Cursor** or
**Add to VS Code**. Your editor opens a confirmation dialog with the server already filled
in — nothing is written until you approve it.

## Two connection patterns

Every MCP client falls into one of two camps. Find yours below, or match the pattern.

**Pattern A — native remote HTTP.** The client accepts a URL, and either runs the OAuth
flow for you or lets you set custom headers. Nothing to install.

**Pattern B — stdio bridge.** The client only speaks stdio to a local process. Use
`mcp-remote`, which bridges stdio to a remote HTTP MCP server. It handles OAuth on its own
if you give it the connector URL:

```
npx -y mcp-remote https://schedulenchill.com/mcp-oauth
```

or carries a static key if you prefer:

```
npx -y mcp-remote https://schedulenchill.com/mcp --header "Authorization: Bearer YOUR_API_KEY"
```

Requires Node.js 18+. Nothing to install ahead of time — `npx` fetches it.

---

## Claude Code

Pattern A. One command, no key:

```bash
claude mcp add --transport http schedulenchill https://schedulenchill.com/mcp-oauth
```

Then run `/mcp`, pick `schedulenchill`, and approve it in the browser window that opens.
`claude mcp list` shows *Needs authentication* until you do.

Prefer a key? Same command with the other endpoint and a header:

```bash
claude mcp add --transport http schedulenchill https://schedulenchill.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"
```

Then in any session: *"Schedule a LinkedIn post for Tuesday 9am about our launch."*

Check it registered with `claude mcp list`. Add `--scope project` to commit the server to
a repo's `.mcp.json` and share it with your team (put the key in an env var first — do not
commit it).

## Claude Desktop

Claude Desktop's remote connectors expect OAuth, and this server now speaks it. Add it under
**Settings → Connectors → Add custom connector** and paste
`https://schedulenchill.com/mcp-oauth` — no config file, no key.

The bridge below is still there if you would rather authenticate with an API key. Edit
`claude_desktop_config.json` (**Settings → Developer → Edit Config**):

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

Restart Claude Desktop fully (quit, don't just close the window). The tools appear under
the connectors icon.

## Cursor

**One click:** press **Add to Cursor** on the Connect AI Tool page in your account.

Prefer to do it by hand? Create `.cursor/mcp.json` in your project, or
`~/.cursor/mcp.json` for every project:

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

Enable it under **Settings → MCP**.

## VS Code (GitHub Copilot agent mode)

**One click:** press **Add to VS Code** on the Connect AI Tool page in your account.

By hand — create `.mcp.json` in your workspace:

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

Open Chat, switch to **Agent** mode, and the tools appear in the tools picker.

## Gemini CLI

Pattern A. Edit `~/.gemini/settings.json`:

```json
{
    "mcpServers": {
        "schedulenchill": {
            "httpUrl": "https://schedulenchill.com/mcp",
            "headers": { "Authorization": "Bearer YOUR_API_KEY" }
        }
    }
}
```

Verify with `/mcp` inside the CLI.

## Codex CLI

Pattern B is the reliable route. Edit `~/.codex/config.toml`:

```toml
[mcp_servers.schedulenchill]
command = "npx"
args = [
  "-y",
  "mcp-remote",
  "https://schedulenchill.com/mcp",
  "--header",
  "Authorization: Bearer YOUR_API_KEY",
]
```

Recent Codex builds can talk to streamable-HTTP servers directly, but that path has moved
around between releases. The bridge works on every version.

## Windsurf

Pattern A. Edit `~/.codeium/windsurf/mcp_config.json`:

```json
{
    "mcpServers": {
        "schedulenchill": {
            "serverUrl": "https://schedulenchill.com/mcp",
            "headers": { "Authorization": "Bearer YOUR_API_KEY" }
        }
    }
}
```

## Zed

Pattern B, via Zed's context servers. In `settings.json`:

```json
{
    "context_servers": {
        "schedulenchill": {
            "command": {
                "path": "npx",
                "args": [
                    "-y",
                    "mcp-remote",
                    "https://schedulenchill.com/mcp",
                    "--header",
                    "Authorization: Bearer YOUR_API_KEY"
                ]
            }
        }
    }
}
```

## Kimi CLI

Pattern A. Edit `~/.kimi/mcp.json` — the format is deliberately Claude-Desktop-compatible:

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

Manage servers with `kimi mcp` (add, list, remove), or point at a specific file with
`kimi --mcp-config-file /path/to/mcp.json`.

## OpenClaw

Pattern A. One command:

```bash
openclaw mcp add schedulenchill \
  --url https://schedulenchill.com/mcp \
  --transport streamable-http \
  --header "Authorization: Bearer YOUR_API_KEY"
```

Or edit `~/.openclaw/openclaw.json` directly — note servers live under `mcp.servers`, not
a top-level `mcpServers`:

```json
{
    "mcp": {
        "servers": {
            "schedulenchill": {
                "url": "https://schedulenchill.com/mcp",
                "transport": "streamable-http",
                "headers": { "Authorization": "Bearer YOUR_API_KEY" }
            }
        }
    }
}
```

Check it with `openclaw mcp doctor schedulenchill --probe`. OpenClaw expands `${ENV_VAR}`
in config, so put the key in an env var rather than committing it.

## Hermes

Pattern A, YAML. Edit `~/.hermes/config.yaml` and add a top-level `mcp_servers` key:

```yaml
mcp_servers:
  schedulenchill:
    url: "https://schedulenchill.com/mcp"
    headers:
      Authorization: "Bearer ${SCHEDULENCHILL_KEY}"
```

Then `hermes mcp test schedulenchill`, pick tools with `hermes mcp configure
schedulenchill`, and reload with `/reload-mcp` (or restart the gateway).

## ChatGPT

Supported, over OAuth. Use the connector URL, not the API-key endpoint:

```
https://schedulenchill.com/mcp-oauth
```

**Settings → Connectors → Add**, paste the URL, and approve the consent screen. There is no
header or key field to fill in — ChatGPT registers itself and gets its own token.

Adding a custom connector needs a paid ChatGPT plan with developer mode enabled. If you do
not have that, any ChatGPT surface that can call an HTTP API can use the
[REST API](/help/developers/rest-api) with a key instead.

## Any other MCP client

This covers n8n, LangChain, CrewAI, LibreChat, custom agents, and anything else that
speaks MCP.

Ask one question: **can it take a remote MCP URL with custom headers?**

- **Yes** → Pattern A. URL `https://schedulenchill.com/mcp`, header
  `Authorization: Bearer YOUR_API_KEY`. The exact JSON key differs per client (`url`,
  `httpUrl`, `serverUrl`), so copy the shape its own docs use.
- **No, stdio only** → Pattern B with the `npx mcp-remote` command above.

From your own code, use any MCP client library with the same URL and header. The server
speaks standard streamable HTTP MCP — there is nothing bespoke to implement.

If your client isn't listed and you get it working, tell us and we'll add it.

---

## Verify the connection

Ask your tool: *"List my connected social accounts."* It should call `get_accounts` and
return your channels.

If nothing happens, work through these in order:

| Symptom | Cause | Fix |
|---|---|---|
| Tools don't appear at all | Client not restarted | Fully quit and reopen — most clients read MCP config only at startup |
| `401 Unauthorized` | Key wrong, expired, or revoked | Generate a fresh key in **Settings → API Keys** |
| `401` only on media upload | Token lacks `*` abilities | Create a new key with default (`*`) abilities |
| `platform_unavailable` | Targeting a platform not open on your account | Call `get_accounts` first — post only to what it returns |
| `429 Too Many Requests` | Rate limit | 60 requests/min on MCP. Back off and retry after `Retry-After` |
| Bridge errors mentioning `npx` | Node.js missing or too old | Install Node.js 18+ |

## First things to try

Start with this one. It reads before it writes, so you can confirm the connection works
without publishing anything:

> [!Try this prompt]
> Using Schedule & Chill, list my connected social accounts. Then write a short LinkedIn
> post about what I shipped this week and schedule it for 5 minutes from now — show me
> the draft first so I can approve it.

Five minutes, not next week — the point of the first run is watching it actually publish.

Then, in plain language:

- *"List my connected social accounts."*
- *"Draft a LinkedIn post about shipping our free tier and schedule it for 10 minutes from now."*
- *"Upload `~/Videos/demo.mp4` and schedule it to LinkedIn tomorrow morning."*
- *"What's in my posting queue this week?"*
- *"Cancel the post scheduled for Friday."*

Uploading a video from your own machine works even for large files — see
[Uploading video from your computer](/help/developers/rest-api/media). Your AI tool streams it in
chunks rather than posting one huge request, so there's no size cliff.

## What your AI tool can do

Full parameters in [Tools](/help/developers/mcp/tools).

| Tool | What it does |
|---|---|
| `get_accounts` | List connected channels. **Always call this first.** |
| `get_groups` | List saved channel groups |
| `schedule_post` | Schedule or publish immediately |
| `update_post` | Edit a draft or scheduled post |
| `get_post` | Read one post and its per-channel status |
| `list_scheduled` | See the queue |
| `cancel_post` | Remove a scheduled post |
| `upload_media` | Upload from a URL, or stream a local file of any size |
| `browse_media` | Search the media library |
| `get_stats` | Posting stats |