GreatWait

npx add-mcp 'https://api.greatwait.dev/mcp'

GreatWait is a remote MCP server. Most clients only need its address.

What	Where
Server address	https://api.greatwait.dev/mcp
Discovery	https://api.greatwait.dev/.well-known/oauth-protected-resource/mcp

When you approve the connection, pick the project it works in. To work in another project, connect again.

Your first callback

Coding agents like Claude Code, Codex and Cursor can make the webhook.site URL themselves. In a chat-only client, paste one from webhook.site.

The agent schedules the call with that URL directly. It never sees the signing secret. That stays on the endpoint’s page in the dashboard.

This is what a connected client does:

#	Tool or resource	What it is for
1	tool schedules_create	Create a schedule
2	tool schedules_read	Read a schedule
3	tool occurrences_list	List retained occurrences
4	tool occurrences_read	Read an occurrence
5	tool attempts_list	List delivery attempts
6	tool attempts_read	Read a delivery attempt
7	tool schedules_cancel	Cancel a schedule

Cancelling comes last, and only stops a schedule that hasn’t fired yet. Once a one-shot has delivered there’s nothing to cancel, and the call answers state_conflict.

Your client asks for full access, including billing and API keys. If that’s more than you want, connect with an API key that has only the scopes you pick.

Claude Code

Anthropic’s coding agent, in the terminal and the editor. It speaks the newest protocol revision, so it is the strictest of the three about what the server sends.

1. Add the server to Claude Code. One command, one address. Claude Code reads the discovery document itself and marks the server as needing authentication. Add –scope user to make it available in every project rather than only this one.

claude mcp add --transport http greatwait https://api.greatwait.dev/mcp

2. Authorize it. Claude Code registers itself and opens GreatWait’s consent screen in your browser. Pick the project, then approve. Inside a Claude Code session the same step is /mcp, then the server, then Authenticate.

claude mcp login greatwait

3. Check it is connected. Connected means authorized and the tool list was read. Inside a session, /mcp lists the tools themselves. A connection authorized for fewer scopes lists fewer tools, which is the quickest way to tell a scope problem from a connection problem.

claude mcp get greatwait

Authenticate with an API key

Claude Code saves the key in plain text in ~/.claude.json, where anything running as you can read it.

1. Create a key. On the API keys panel, select New key and tick endpoints:write, occurrences:read, schedules:read, schedules:write. The key is shown once.
2. Add the server with the key. Replace the placeholder with your key. If greatwait is already added, remove it first with claude mcp remove greatwait.

claude mcp add --transport http greatwait https://api.greatwait.dev/mcp --header "Authorization: Bearer <the key, shown once at creation>"

Codex

OpenAI’s coding agent, in the terminal. Its MCP client is its own implementation, and it holds each change for your approval before making it.

1. Add the server to Codex. One command, one address. Codex writes the server into ~/.codex/config.toml, sees that it needs authorizing, and goes straight on to the sign-in below.

codex mcp add greatwait --url https://api.greatwait.dev/mcp

2. Authorize it. Codex registers itself and opens GreatWait’s consent screen in your browser. Pick the project, then approve. Run this only if the add step’s sign-in was closed before it finished.

codex mcp login greatwait

3. Check it is authorized. The greatwait line shows OAuth once the approval landed. Inside a Codex session, /mcp lists the tools. Codex asks you to approve each tool call that changes something, such as creating a schedule; reads run without asking.

codex mcp list

Authenticate with an API key

Codex reads the key from an environment variable, so it sits in plain text wherever you set that, such as your shell profile.

1. Create a key. On the API keys panel, select New key and tick endpoints:write, occurrences:read, schedules:read, schedules:write. The key is shown once.
2. Put the key in an environment variable. Replace the placeholder with your key. Add the line to your shell profile so every terminal Codex starts from has it.

export GREATWAIT_API_KEY="<the key, shown once at creation>"

3. Add the server with the key. Codex writes the server into ~/.codex/config.toml with the variable’s name, not the key. If greatwait is already added, remove it first with codex mcp remove greatwait.

codex mcp add greatwait --url https://api.greatwait.dev/mcp --bearer-token-env-var GREATWAIT_API_KEY

Cursor

The AI code editor. Its MCP client is its own implementation rather than the reference SDK, and it was the first client proven against production.

1. Add the server to Cursor’s MCP configuration. One entry, one address. Cursor reads the discovery document itself and works out that the server needs authorizing.

In ~/.cursor/mcp.json:

{
  "mcpServers": {
    "greatwait": {
      "url": "https://api.greatwait.dev/mcp"
    }
  }
}

2. Authorize it. Cursor registers itself and opens GreatWait’s consent screen in your browser. Approve it there. Inside the editor the same step is the sign-in prompt beside the server in settings.

cursor-agent mcp login greatwait

3. Check what it can do. The tools your connection is allowed to see. A connection authorized for fewer scopes lists fewer tools, which is the quickest way to tell a scope problem from a connection problem.

cursor-agent mcp list-tools greatwait

Authenticate with an API key

Cursor saves the key in plain text in ~/.cursor/mcp.json, where anything running as you can read it.

1. Create a key. On the API keys panel, select New key and tick endpoints:write, occurrences:read, schedules:read, schedules:write. The key is shown once.
2. Add the key to Cursor’s MCP configuration. Replace the placeholder with your key. It isn’t shown again anywhere.

In ~/.cursor/mcp.json:

{
  "mcpServers": {
    "greatwait": {
      "headers": {
        "Authorization": "Bearer <the key, shown once at creation>"
      },
      "url": "https://api.greatwait.dev/mcp"
    }
  }
}

Turning a connection off

Open Settings → Access.

• A client you signed in with OAuth is under Connected applications. Select Withdraw access, then Withdraw it. Its next tool call is refused.
• A key is under API keys. Select Revoke, then Revoke it. That can’t be undone. To reconnect, make a new key with New key and update the client’s settings.

Troubleshooting

What you see	What to do
The consent screen refuses before showing any scopes, naming the redirect.	Close any earlier sign-in tab and sign in again: claude mcp login greatwait in Claude Code, codex mcp login greatwait in Codex or cursor-agent mcp login greatwait in Cursor. A half-finished earlier sign-in is the usual cause.
You approved in the browser, but the client still says the server needs authentication.	Sign in again with the same command. A sign-in code works once and expires quickly.
The client says the server needs authentication, or lists no tools at all.	The connection isn’t signed in. With OAuth, run your client’s login command again. With a key, check you copied all of it. It’s shown once, and part of a key fails just like a wrong one.
Calls that worked a moment ago now fail every time.	Someone revoked the key, and that can’t be undone. Create a new key on the API keys panel and put it in the client’s settings.
Calls fail every time, starting at a deadline you were told about.	The key was rotated and the old one has stopped working. Use the new key you were shown when you rotated. If you didn’t keep it, rotate again.
Some tools work, and one fails naming the scope it needs.	The connection doesn’t have that scope. With OAuth, sign in again and approve it. With a key, create a new key that has it. A key’s scopes can’t be changed.
A tool call names a schedule or endpoint the connection can’t see.	Each connection works in one project, so an ID copied from another project isn’t there. Ask the client to list what it can see and use an ID from that.
A tool call is refused for an argument the client thought was optional.	An argument naming another project is refused, not ignored. Drop it. The connection already knows its project.

Cookie settings