The NoClick MCP server

Let Claude, ChatGPT, Cursor or any MCP client build on the platform, signed in with OAuth or with a platform key.

The platform is also an MCP server. Connect Claude, ChatGPT, Cursor, Codex or any other MCP client to it, and the agent in that client can create agents and resources, connect accounts, deploy apps, buy what has a price and read what happened, just as your code would. Every call it makes meets the same scopes, spend caps and approval rules as your code's.

The server is at:

POST https://mcp.noclick.com

It speaks Streamable HTTP. A client either signs in with OAuth, where you choose on NoClick what the connection may do, or sends a platform key as Authorization: Bearer nk_live_.... Its tools are a few task-shaped ones (search and fetch for docs, skills and objects, resources_save, apps_deploy, quote then purchase, wait for long work) plus api_describe and api_call for any other API operation. Creating keys, changing policy and reading secrets' values stay with a person. A spending limit only tightens through it: lowering one (or setting one where there's none) goes straight through, and raising or removing one waits for your approval (spend).

What waits for your approval (a purchase over what the connection may spend by itself, a deletion that can't be undone, a call your policy holds, a raised limit) reaches you from NoClick itself: a link on the app you last texted NoClick on (WhatsApp or iMessage), else by email. It opens what's asked (the exact price, what a deletion takes with it, any terms to accept), and you approve or decline it there with one tap, without signing in. The link works once, for 24 hours. A purchase or deletion your NoClick assistant asks for while you're watching its chat is a card right there, and the link follows only if you leave it unanswered. The agent's call answers approval_required with sent_to naming where the link went, never the link, so no agent can approve its own call.

Claude and ChatGPT

Add https://mcp.noclick.com as a custom connector. The first time the client uses it, NoClick asks you to sign in and choose what the connection may do: build, deploy, spend (with a monthly cap, and an amount under which a purchase needs no approval) and delete. Reading is always allowed. Each connection is listed under Connected apps beside your API keys in the developer console, where you can revoke it.

Claude Code

claude mcp add --transport http noclick https://mcp.noclick.com

Then run /mcp in Claude Code to sign in. To use a platform key instead:

claude mcp add --transport http noclick https://mcp.noclick.com \
  --header "Authorization: Bearer $NOCLICK_API_KEY"

Cursor

Add this to .cursor/mcp.json, or leave out headers to sign in with OAuth:

{
  "mcpServers": {
    "noclick": {
      "url": "https://mcp.noclick.com",
      "headers": { "Authorization": "Bearer ${env:NOCLICK_API_KEY}" }
    }
  }
}

Other clients

Any client that supports remote MCP servers over HTTP works the same way: the URL above, and either its OAuth sign-in or Authorization: Bearer with your key. A few take it in a shape of their own:

ChatGPT adds custom connectors in developer mode: turn on Developer mode under Settings > Apps & Connectors > Advanced settings, click Create, paste the URL, then turn the connector on in a chat from the + menu. On a team plan, an admin allows developer mode first.
Codex CLI: codex mcp add noclick --url https://mcp.noclick.com.
Windsurf names the URL serverUrl, not url, in ~/.codeium/windsurf/mcp_config.json:
```
{ "mcpServers": { "noclick": { "serverUrl": "https://mcp.noclick.com" } } }
```
Claude Desktop takes the server as a custom connector, as Claude does. From its config file instead, it reaches a remote server through mcp-remote:
```
{ "mcpServers": { "noclick": { "command": "npx", "args": ["-y", "mcp-remote", "https://mcp.noclick.com"] } } }
```

Connected before at https://api.noclick.io/mcp? That's the workflow MCP server, which keeps working.

The tools

Every tool tells the client what it changes (MCP's read-only, destructive, idempotent and open-world hints), so a client can run reads without asking and ask a person before the rest. A write creates or changes your account's own things; a sensitive tool sends, spends, deletes or puts something live, and clients should ask before each call. These are the three classes connector directories sort tools into (read, write and sensitive write), and a tool that both reads and writes counts as a write.

Tool	What it does	Kind
`search`	Finds docs, skills, examples, API operations and your account's objects	Read
`fetch`	Reads one doc page, skill or object in full, a file in a bucket included	Read
`account_status`	Balance, spend, approvals waiting and what's failing	Read
`logs`	Bounded logs of a deployment, app, agent conversation, call or trigger	Read
`wait`	Waits up to 40 seconds on long work and returns its result	Read
`approvals`	Calls held for a person's approval (purchases, deletions, what your policy holds); it never approves. Questions sent to a person are operations: `wait` on one	Read
`quote`	Prices a phone number, domain or machine; buying (and a number's quote) needs $5 of funds you added, while searching what's for sale and its price is free	Read
`api_describe`	Describes any API operation	Read
`agents_save`	Creates an agent, or updates one by name (an update replaces the fields it sets)	Write
`agents_test`	Runs a turn of an agent against a simulated world: nothing real is sent, bought or changed	Write
`workflows_save`	Has NoClick's builder build a workflow from a description, or change one by name, and answers what it asks	Write
`resources_save`	Creates or updates a database, bucket, volume, queue, channel, inbox, webhook, trigger, a file in a bucket and more	Write
`secrets_request`	Creates a secret by name and returns the NoClick page where a person types its values	Write
`render`	Draws an answer as a picture or a PDF in NoClick's design (a comparison, a series, a week, a market, a choice of designs) and returns the line that puts it in a reply; the picture is kept as one of your files, its link showing it for 7 days	Write
`repos_push`	Commits files to a repo (adding, replacing or deleting them, each from its content or a `source` NoClick reads: a file it was sent, a URL, a bucket's file), or returns a push remote	Write
`connections_connect`	Returns the link a person opens to connect an account; it can email the link to them	Sensitive when it emails
`apps_deploy`	Deploys a preview of a branch, or production, which replaces what's live	Sensitive for production
`agents_message`	Gives an agent a live turn, in which its own tools act for real	Sensitive
`purchase`	Buys what `quote` priced, once a person agreed	Sensitive
`delete`	Previews what a deletion does, then deletes, cancels or revokes	Sensitive
`api_call`	Calls any other API operation by name; purchases and deletions are refused there	Sensitive

Errors say what went wrong and what to do next, and long work returns an operation to wait on. Each connection is rate limited like an API key.

Other URLs on the server

URL	What it serves
`https://mcp.noclick.com`	the task tools above
`https://mcp.noclick.com/readonly`	the tools that read, `api_describe`, and `api_call` limited to reads
`https://mcp.noclick.com/code`	the task tools plus `query` and `run`, which run a short Python program against the SDK in a sandbox
`https://mcp.noclick.com/directory`	the task tools without `api_describe`, `api_call`, `quote` and `purchase` (below)
`https://mcp.noclick.com/x/{area}`	one tool per API operation of one area, such as `agents` or `phone`

Each of them also acts for one of your users: https://mcp.noclick.com/u/{user_id}, https://mcp.noclick.com/u/{user_id}/readonly and so on make every call as that user, for clients that can't send the NoClick-User header.

The server's playbooks are skills: listed in its instructions, read with fetch (skill:<name>), offered as prompts, and indexed at https://mcp.noclick.com/.well-known/skills/index.json for agents that discover skills by URL.

The directory URL

https://mcp.noclick.com/directory is the server as AI clients' connector directories list it. It serves 17 of the 21 task tools: all of them except quote, purchase, api_describe and api_call.

It can't buy. quote and purchase are left out, and its sign-in page doesn't offer the spend permission, so a directory connection can't buy a phone number, a domain or a machine itself.
It has no catch-all tool. api_call runs any API operation by name and api_describe explains any of them. A directory asks for tools that each do one job, so you, your client and the directory's reviewers can tell from a tool's name what a call will do.
The rest is the same. It reads, builds agents, workflows and resources, commits to repos, deploys, connects accounts, gives agents live turns and deletes, under the same consent, caps and approval rules as the default URL.
Its skills are its own. Each calls only the tools it has, and the ones about buying, or about putting work on a queue, aren't offered. Its prompts and fetch serve them; the well-known skills index lists the default URL's, because a well-known path belongs to the whole mcp.noclick.com origin, which both URLs share.

To buy, or to reach an API operation the task tools don't cover, connect https://mcp.noclick.com instead.

Give your hosted agents the same tools

"noclick" in a hosted agent's tools gives it the same server's core tools (search, fetch, api_describe, api_call, quote, buy and delete), acting as each turn's key, under the same rules: a deletion to the trash happens at once, restorable for 30 days, a purchase or a deletion that can't be undone waits for your account's owner, and a secret's value never comes from its conversation. noclick.Platform.only("read") or noclick.Platform.only("domains") narrows it. See Give it NoClick itself.

A connected app gives an agent nothing it wasn't granted itself: an app without spend can't give one "noclick" (or noclick.spend) or a card's purchase, one without delete can't give it agents.cancel (so not all of "agents"), and a turn it starts reaches only the groups it holds. Nor can it change what an agent holding more does on other people's turns: its instructions, memories, triggers, wake-ups, or the inboxes and numbers that wake it. It can still message that agent, take its tools away and delete it.

What such an app says to an agent holding more stays apart from everyone else's conversations with it, since their turns hold more: its messages go to conversations of its own, mcp:<its key id>:<the conversation it named> (the message's operation names the one it went to), and its turns there write nothing elsewhere (the agent's memory, the owner's conversation, a wake-up in another conversation). An agent it fully reaches is talked to in the conversation it names. Your NoClick assistant (the agent coordinator) is NoClick's, so it can't be deleted.

Keep the agent's key narrow

The agent can do whatever its key can. Give it a key of its own with only the scopes it needs, and a monthly spend cap (see API keys and scopes). Your policy applies to it like any other caller, so tools you've forbidden stay forbidden and approvals still go to a person.

MCP servers for your users

This server is for you and your coding agents. If you run an MCP server of your own for your users, a toolkit gives you NoClick's tools to serve from it: definitions("mcp") for the tool list and call() to run each one as the right user.

Troubleshooting

"localhost refused to connect" after you approve. A command-line client (Claude Code, Codex) signs in through a short-lived server on your own machine, and NoClick's approval page sends your browser back to it. Nothing answers there once that session has closed or timed out, or when you approve from a tab an earlier attempt opened. Sign in again (in Claude Code, /mcp, the server, then Authenticate), keep the session open, and approve in the tab it opens.

The client runs over SSH or in a container. Its localhost is that machine, not your browser's. Forward the port in the callback URL (ssh -L <port>:localhost:<port> ...), or copy the URL from the approval page and open it on that machine, with curl '<url>' for instance.

The tools don't show up. Restart the client after adding the server, check that its config file is valid JSON, and in Claude Code see claude mcp list. Most clients connect only when a session starts.

Support

Email support@noclick.com for help with the server or a connection. The privacy policy says what NoClick keeps and for how long, and the developer terms, with the acceptable use policy, cover using it. To end a connection, revoke it under Connected apps in the developer console.