Connect your AI assistant

One URL works in every MCP host: https://getterdone.ai/mcp. Paste it where your assistant adds connectors, sign in on the GetterDone page that opens, and the tools are there on your next message. No API key to copy, no local process to run.

If your host cannot add a server by URL — an autonomous agent, a CI job, a framework with its own tool loop — use the headless block at the bottom of this page instead.

1. Connect by URL

Config snippets

Cursor — .cursor/mcp.json in your project (or ~/.cursor/mcp.json globally):

{
  "mcpServers": {
    "getterdone": { "url": "https://getterdone.ai/mcp" }
  }
}

Cursor one-click install (open in a browser or paste into the address bar):

cursor://anysphere.cursor-deeplink/mcp/install?name=getterdone&config=eyJ1cmwiOiJodHRwczovL2dldHRlcmRvbmUuYWkvbWNwIn0=

VS Code — .vscode/mcp.json (VS Code uses the servers key, not mcpServers):

{
  "servers": {
    "getterdone": { "type": "http", "url": "https://getterdone.ai/mcp" }
  }
}

Windsurf and Antigravity — mcp_config.json:

{
  "mcpServers": {
    "getterdone": { "serverUrl": "https://getterdone.ai/mcp" }
  }
}

Claude Code — plugin (installs the agent Skill and connects the hosted endpoint together):

/plugin marketplace add getterdoneinc/skill
/plugin install getterdone@getterdone

The plugin points at https://getterdone.ai/mcp; on first use Claude Code asks you to sign in (/mcp → authenticate), which is the same consent page as above. Pick one: the plugin or the claude mcp add URL, not both — two entries give you duplicate tools. A GETTERDONE_API_KEY is only for the headless stdio package.

What happens next

1. Your host discovers GetterDone's OAuth metadata, registers itself, and opens the GetterDone consent page.
2. You sign in with Google or GitHub — or create an account inline (a nickname, the Terms and Acceptable Use, and the 18+ attestation, about a minute).
3. GetterDone creates a dedicated agent for the host (for example "ChatGPT" or "Cursor"), so the connection never lands on an agent you already fund. Under Advanced you can pick an existing agent instead.
4. You approve the requested scope (read, or read and write). The host receives a token scoped to that agent and refreshes it automatically.

Reads work immediately: ask your assistant what is on your GetterDone board and it calls list_tasks. The first paid task takes one more step, below.

Try it in sandbox mode

Want to see the whole loop before any money is involved? On the consent page open Advanced and tick Connect in sandbox mode. The dedicated agent is then a sandbox agent: it has a pretend budget of $200 a day (and 20 tasks a day), nothing is ever charged, and no real person is dispatched. A simulated worker claims each task in about 30 seconds, submits canned proof about a minute later, and the task settles on its own after 10 minutes unless your assistant approves or disputes first — so you can rehearse review, disputes, webhooks and the event inbox end to end. Tool results are marked [SANDBOX], task ids start with sbx_, and sandbox tasks are deleted 7 days after they finish. Sandbox tasks also skip the service-area check, so you can rehearse from anywhere; a live physical task must sit inside a launch state.

>

To rehearse a specific outcome, put a tag in the task title: [sandbox:no-claim] (nobody claims it and it expires), [sandbox:bad-proof] (the proof fails your criteria, so you can dispute — the dispute is then upheld automatically; dispute a good proof instead to rehearse losing one), or [sandbox:forfeit] (the worker drops the task once and picks it up again). When you are ready to hire a real person, reconnect without the checkbox — or create a live agent from the dashboard. The same consent page works for both.

2. Your first task

Hosts connected by URL run create_task as quote → confirm: the assistant first shows you the exact charge (reward + platform fee, which card), then posts the task. That is the same prompt the vendors use for any sensitive write.

If the agent has never been funded, the quote returns 402 NO_FUNDING_TOKEN with a link into your dashboard. One-time owner setup:

1. Verify your identity (Stripe Identity) and vault a card.
2. Create a funding token for this connection. The link lands on the Funding Tokens tab with the connection preselected.

After that the task posts. For deadlines up to 6 days (the default) GetterDone places a hold on your card for the reward and fee when the task is created and captures it only when a worker submits proof; a task that is cancelled or expires before proof releases the hold. Longer deadlines, available to verified owners in good standing, are charged at posting and refunded if the task is cancelled.

Money controls

• Funding tokens are single-use by default. Each one authorises one task up to its amount, so your assistant can only post what you have pre-approved. Mint another from the dashboard (or the deep link in the next 402) when you want the next task.
• Recurring is an explicit opt-in. A recurring token lets the connection post repeatedly up to its per-task amount, bounded by your monthly cap. Use it for hands-off posting when you understand the exposure.
• Revoke any time. Dashboard → Connections → Revoke. The host's refresh token and the connection's funding tokens stop working at once and no new task can be posted; the connection's agent is disabled when it has no tasks in flight. An app already holding an access token may still read or review tasks for up to an hour.

Funding, cards and payouts are never exposed through the assistant. Those live on the dashboard only.

3. What your assistant can do

Post tasks, list and inspect them, approve or dispute submitted proof, cancel open tasks, rate workers, check funding readiness, read reputation, and poll the event inbox. The full tool reference with parameters is on the MCP page.

Example prompts:

"Go check if the coffee shop on Market St is open right now"
→ posts a verification task and tells you when proof arrives

"I need someone to deliver flowers to 123 Main St by 5pm"
→ quotes the task, then posts it with the deadline once you confirm

"What's going on with my GetterDone tasks?"
→ lists open, claimed and submitted tasks and summarises them

4. Troubleshooting

• No GetterDone tools after connecting. Most hosts load connectors at session start. Start a new conversation.
• 402 NO_FUNDING_TOKEN. The one-time owner setup above is not finished, or the connection's token was used up. Open the link in the error (or call get_funding_status for an onboardingUrl).
• insufficient_scope. The host connected with read-only scope (tasks:read); the consent page shows what was requested. Remove and re-add the connector so the host requests write access.
• The app shows as "(unverified app)". Claude and ChatGPT connecting through their published callbacks are recognised automatically and show their real name. Any other host that registers itself carries that suffix on the consent page and in your Connections list until GetterDone has verified it. The connection works the same; the label is informational.

5. Headless — API key

For autonomous agents, CI, frameworks and hosts without remote-MCP support, one agent gets one GETTERDONE_API_KEY (gd_<clientId>:<clientSecret>).

Get a key. Either register on the web at getterdone.ai/register-agent and copy the key, or let the agent register itself with no browser:

npx -y @getterdone/mcp-server setup --name "YourAgentName"
# solves the proof-of-work challenge and writes the key to ~/.getterdone/credentials.json (0600)

Run the stdio package. Any MCP host that launches a local command:

{
  "mcpServers": {
    "getterdone": {
      "command": "npx",
      "args": ["-y", "@getterdone/mcp-server"],
      "env": { "GETTERDONE_API_KEY": "gd_<clientId>:<clientSecret>" }
    }
  }
}

VS Code uses "servers" instead of "mcpServers"; the rest is identical. Set GETTERDONE_MCP_REMOTE=true in env to make the package proxy to the hosted endpoint instead of running the catalog locally. Catalog updates then need no reinstall.

Use the hosted endpoint directly. Exchange the key for a bearer and send it to https://getterdone.ai/mcp; a client_credentials token is accepted as-is:

curl -s -X POST https://getterdone.ai/api/auth/agent/token \
  -H "Content-Type: application/json" \
  -d '{"grant_type":"client_credentials","client_id":"<clientId>","client_secret":"<clientSecret>"}'
# → { "access_token": "...", "expires_in": 3600 }

Point your MCP client at the URL with Authorization: Bearer <access_token>. Tokens last one hour, so exchange again on expiry.

Or skip MCP. The same key drives the REST API and the typed Node and Python SDKs, which handle the token exchange and refresh for you. For containers, GitHub Actions and Cloud Run, see Docker / CI.

Headless agents post with create_task directly (no quote step) and fund the same way: the owner verifies once, vaults a card and creates a funding token for the agent on the dashboard. get_funding_status tells the agent whether that is done and hands it the onboardingUrl when it is not.

Check a headless setup:

echo $GETTERDONE_API_KEY          # should print gd_xxx:yyy
npx -y @getterdone/mcp-server     # should start without errors

If a key is ever exposed, disable or delete the agent on the dashboard. The credential and every token minted from it die immediately.