MCP Server: Connect Claude, Cursor and ChatGPT

GetItDone runs a remote Model Context Protocol (MCP) server, so AI assistants like Claude can list, create, update, and archive your tasks — with the same rich context the product itself has, including task images and extracted video frames.

Any MCP client that speaks remote servers can connect: no local install, no sidecar process. There are two ways to authenticate — pick whichever your client supports:

• Sign in (OAuth) — paste the server URL into the client, sign in to GetItDone, and approve access. No key to create or store. Works with every client in Connect your client.
• API key — send a gid_ key in a header. Best for scripts, CI, and clients that take a JSON config with headers.

Step-by-step for one assistant: Use GetItDone in Claude.

EndpointCopy Anchor Link

• URL: https://app.nowgetitdone.com/api/mcp
• Transport: Streamable HTTP
• Auth: OAuth 2.1 sign-in, or an API key sent as Authorization: Bearer <gid_ API key>

Sign in with OAuth — no API keyCopy Anchor Link

The server implements the MCP authorization spec: an unauthenticated request gets a 401 pointing at https://app.nowgetitdone.com/.well-known/oauth-protected-resource, and clients register themselves (dynamic client registration) and sign you in with OAuth 2.1 + PKCE. In practice:

1. Add https://app.nowgetitdone.com/api/mcp as a remote MCP server in your client.
2. Your browser opens GetItDone — sign in if you are not already.
3. The consent screen lists exactly what the assistant is asking for (for example Read tasks, Write tasks) and which workspaces it may use: only the workspace you are in by default, the ones you tick, or All my workspaces. Choose Allow access.

An app connected to several workspaces must say which one each call is for. Leaving a workspace also ends every connection's access to it. Apps you connected before this choice existed keep reaching all your workspaces until you disconnect and connect them again.

To disconnect later, ask your agent to call revoke_connected_app, or revoke the app from your profile under Connected Apps. Access tokens last 30 days by default, but every request checks that the connection is still approved, so revoking takes effect at once: the app cannot get new access, and a token it already holds is refused on its next request.

Get an API keyCopy Anchor Link

1. Sign in at app.nowgetitdone.com.
2. Go to Profile → API Keys (app.nowgetitdone.com/settings/api-keys).
3. Create a key — keys start with gid_ and are shown once, so store them safely.

The same key authenticates the public /v1 REST API; test keys are prefixed gid_test_.

Connect your clientCopy Anchor Link

Buttons for Claude and ChatGPT open the directory listing; the others install directly or jump to the instructions.

GetItDone's MCP server is a hosted Streamable HTTP endpoint with OAuth 2.1 sign-in. There is nothing to install or run: point the client at the URL below and sign in to GetItDone when the browser opens. Every client that supports remote MCP servers with OAuth works; the ones below are the common ones.

https://app.nowgetitdone.com/api/mcp

Claude and Claude DesktopCopy Anchor Link

• claude.ai / Claude Desktop: open GetItDone in the Claude connector directory and click Connect, then sign in. Manual alternative: Settings → Connectors → Add custom connector, paste the URL, then sign in. Step by step: Use GetItDone in Claude.

Claude CodeCopy Anchor Link

Claude Code, signing in (then run /mcp inside Claude Code and follow the browser sign-in):

claude mcp add --transport http getitdone https://app.nowgetitdone.com/api/mcp

Claude Code with an API key instead:

claude mcp add --transport http getitdone https://app.nowgetitdone.com/api/mcp \
  --header "Authorization: Bearer gid_YOUR_API_KEY"

ChatGPT and CodexCopy Anchor Link

• ChatGPT: one click: Open GetItDone in ChatGPT opens GetItDone's published ChatGPT app; choose Connect, then sign in. Manual: Settings → Apps & Connectors → Create (developer mode), name it GetItDone, paste the URL, authentication OAuth.
• Codex CLI: add to ~/.codex/config.toml:

[mcp_servers.getitdone]
url = "https://app.nowgetitdone.com/api/mcp"

Cursor and other JSON-config clientsCopy Anchor Link

One click: Add to Cursor. Or in .cursor/mcp.json (Cursor prompts for the OAuth sign-in on first use):

{
    "mcpServers": {
        "getitdone": {
            "url": "https://app.nowgetitdone.com/api/mcp"
        }
    }
}

Any remote-MCP client that takes a JSON config can use an API key instead of signing in — add the header:

{
    "mcpServers": {
        "getitdone": {
            "url": "https://app.nowgetitdone.com/api/mcp",
            "headers": {
                "Authorization": "Bearer gid_YOUR_API_KEY"
            }
        }
    }
}

VS Code and GitHub CopilotCopy Anchor Link

One click: Add to VS Code. Or run MCP: Add Server → HTTP and paste the URL, which writes to .vscode/mcp.json:

{
    "servers": {
        "getitdone": {
            "type": "http",
            "url": "https://app.nowgetitdone.com/api/mcp"
        }
    }
}

Google AntigravityCopy Anchor Link

Install the plugin from the repository (or from the Antigravity Marketplace once listed):

agy plugin install https://github.com/DevinoSolutions/mcp-servers/antigravity-plugins/getitdone

Or add the server by hand in ~/.gemini/config/mcp_config.json (Antigravity requires the serverUrl key):

{
    "mcpServers": {
        "getitdone": {
            "serverUrl": "https://app.nowgetitdone.com/api/mcp"
        }
    }
}

GeminiCopy Anchor Link

• Gemini app: Settings → Connected apps → Custom apps → Add a custom app, paste the URL, then mention @GetItDone in a chat. (Custom apps are currently limited to personal Google accounts in the US.)
• Gemini CLI: gemini extensions install https://github.com/DevinoSolutions/mcp-servers then /mcp auth getitdone, or add { "mcpServers": { "getitdone": { "httpUrl": "https://app.nowgetitdone.com/api/mcp" } } } to ~/.gemini/settings.json.

KiroCopy Anchor Link

One click: Add to Kiro. Or in .kiro/settings/mcp.json:

{
    "mcpServers": {
        "getitdone": {
            "url": "https://app.nowgetitdone.com/api/mcp"
        }
    }
}

Perplexity, Mistral Le Chat, GrokCopy Anchor Link

• Perplexity (Pro, Max, Enterprise): Settings → Connectors → Custom connector, paste the URL, authentication OAuth.
• Mistral Le Chat (all plans): Intelligence → Connectors → Add Connector → Custom MCP Connector, paste the URL.
• Grok: grok.com → Connectors → New connector → Custom, paste the URL.

Other clientsCopy Anchor Link

• Replit: Add to Replit, or Integrations → Add MCP server.
• Devin, Windsurf, Zed, JetBrains Junie, Cline, OpenCode: add a remote (HTTP) MCP server with the URL above; each prompts for the OAuth sign-in on first use. Cline can also install it from the Cline marketplace entry using its llms-install.md.

Tokens are scoped to what you approve on the consent screen; a tool you did not grant is never shown to the assistant. Revoke access at any time from your profile under Connected Apps — see Sign in with OAuth.

ToolsCopy Anchor Link

Everything an assistant needs to run a real task workflow — discovery, deep reads, and writes.

The server uses Code Mode. Its tool list (tools/list) has two tools, search_tools and execute_typescript, not one tool per operation. Your assistant calls search_tools to find the tools below, then runs a short TypeScript program through execute_typescript that calls them. Without a query, search_tools answers with a one-line index of every tool (name, title, read-only or write); with tool names as the query, such as list_tasks get_task_details, it answers with the TypeScript declarations of exactly those tools. Any other word matches tool names and titles, and a word that matches many tools answers with their index. Each call goes through the same scope checks as a direct call.

Each tool names the API scope a key must hold: without it search_tools never lists the tool and a call is refused.

• list_workspaces — read · workspaces:read — List the workspaces (organizations) this connection can use, with their ids: the workspaces the user chose when approving the connection, or every workspace they belong to for an API key. Pass a returned id as workspaceId on the other tools to target a specific workspace when there is more than one.
• list_projects — read · projects:read — List the projects in the workspace with their ids — the same grouping the board shows down the side of the task list. Call this BEFORE filing work under a project: pass a returned id as projectId on create_task or update_task, or as a filter on list_tasks. Archived projects are left out unless you pass includeArchived: true, and every project says whether it is archived. Results are paged (limit, default 50, max 200): while nextCursor is not null, call again with cursor set to it and the same other arguments to get the rest. If the project the user named is not in this list it does not exist, so say so (or create it with create_project when the user asks for a new one) rather than inventing it or writing its name into a task.
• list_members — read · members:read — List the members of the workspace with their userId, name, email and role. Pass a returned userId as assigneeUserId on create_task or update_task to assign a task to that person, or on list_tasks to see what they own. Only members of the workspace can be assigned, so look the person up here rather than guessing an id.
• list_tasks — read · tasks:read — List tasks in the workspace. Can filter by status, priority, project and owner/assignee (assigneeUserId, a userId from list_members). Returns the latest version of each task — including its owner (ownerUserId and ownerName), the projects it is filed under, whether it is currently BLOCKED and how many tasks it blocks, and which agent session has claimed it (claim, null when nobody holds it) — so you can tell what is actually actionable right now, where it belongs and who is on it. Pass unclaimedOnly: true to see only tasks no agent is working on. Every row says when the task was last edited (lastEditedAt): pass updatedBefore (a date or date-time) to see only tasks nobody has touched since then, and sort: "staleFirst" to put the task edited longest ago first, so stale work is one cheap call away. To keep the list cheap to read, each task carries only the start of its notes and description (notesPreview, descriptionPreview) and their full lengths (notesLength, descriptionLength); call get_task_details to read the notes of one task, or pass includeNotes: true only when you really need the full text of every task (pages are then at most 20 tasks, and a bigger limit is refused as INVALID_INPUT). Results are paged, newest task first unless sort says otherwise (limit, default 50, max 200): while nextCursor is not null, call again with cursor set to it and the same filters until it is null, or you will miss tasks.
• get_task_details — read · tasks:read — Get the content of a single task: its notes, every attachment (image, video, document) with short-lived URLs the AI can fetch to read the actual content, and its dependency chain — which tasks are blocking it and which tasks it blocks. Use this after list_tasks when you need to see what is inside a task or why it cannot be started. Notes are often a long work log of dated entries, so they come back as a window: by default the NEWEST entries that fit about 12,000 characters, with notesTruncated true when older entries were left out and notesLength giving the full size. A truncated window also lists every left-out entry in notesOmitted, one line each (its stamp and author, size and first words): read only the ones you need by passing the stamp of an entry as both notesSince and notesUntil, rather than re-reading the whole log. Pass notesLastEntries (last N entries), notesSince and notesUntil (entries in a date range) or notesMaxChars (a bigger or smaller budget) to choose the window. While notesTruncated is true you hold part of the log, so never send it back through update_task: add to it with append_task_note. Identify the task with taskId (the id list_tasks and create_task return), shortId (e.g. 123 for T-123) or taskVersionId; at least one is required, and shortId wins over taskId, which wins over taskVersionId. A task that does not exist or is not yours is a TASK_NOT_FOUND error, and an argument this tool does not declare is refused as INVALID_INPUT.
• get_task_video_context — read · tasks:read — Pull visual context from a task's videos: extracts a few evenly-spaced frames from any uploaded video (screen recording etc.) in the task's notes or attachments so you can understand what it shows, and surfaces any YouTube/Vimeo links found in the notes. Use when a task references a video/screen recording. Identify the task with taskId (the id list_tasks and create_task return), shortId (e.g. 123 for T-123) or taskVersionId; at least one is required, and shortId wins over taskId, which wins over taskVersionId. A task that does not exist or is not yours is a TASK_NOT_FOUND error, and an argument this tool does not declare is refused as INVALID_INPUT.
• create_task — write · tasks:write — Create a new task for the current user in their organization. Set a start date when the task cannot be worked on until a given day (defer-until). File it under a project by passing a project id from list_projects. Assign it to a workspace member by passing their userId from list_members as assigneeUserId (it is assigned to you when omitted). Set a recurrence to make it a repeating habit or routine ("every weekday", "every other Monday", "the 1st of each month", "every 3 days after I finish it") — each day is completed independently.
• create_tasks — write · tasks:write — Create multiple tasks in one call — up to 100 tasks at once, each with its own name, status, priority, dates, notes, project, assignee and recurrence. Returns one result per task (shortId on success, error on failure) so partial success is visible. Use this instead of calling create_task in a loop when you have a batch of work to file: it is one metering event, one round trip, and parallel-safe.
• update_task — write · tasks:write — Update an existing task. You can update the name, status, priority, start date, due date, notes, story points, its project (pass a project id from list_projects to move it, or null to remove it from every project), its owner/assignee (pass a userId from list_members as assigneeUserId, or null to unassign), or its repeat schedule (pass a recurrence to start/replace it, or null to stop it repeating). Identify the task with taskId (the id list_tasks and create_task return), its short ID (e.g. T-123) as shortId, or taskVersionId; a call that names none of them is refused, and so is an argument this tool does not declare (INVALID_INPUT).
• complete_task_occurrence — write · tasks:write — Mark one DAY of a repeating task done. This is per-day: completing Monday leaves Tuesday untouched. The day can be in the PAST ("I brushed my teeth yesterday") or a scheduled FUTURE day finished early — neither breaks the chain. A day already marked skipped is changed to done. Identify the task with taskId (the id list_tasks and create_task return), shortId (e.g. 123 for T-123) or taskVersionId; at least one is required, and shortId wins over taskId, which wins over taskVersionId. Pass the day as YYYY-MM-DD, or omit it for today. A task that does not exist or is not yours is a TASK_NOT_FOUND error, and an argument this tool does not declare is refused as INVALID_INPUT.
• link_task_dependency — write · tasks:write — Record that one task is BLOCKED BY another (finish-to-start), or remove that link. Use it whenever the user says one piece of work is waiting on, depends on, or is held up by another. The blocked task is then reported as blocked until every blocker is completed, so you can answer "what is blocking this?" by following the chain of blockers. Identify the blocker with blockerTaskId, blockerShortId (e.g. 123 for T-123) or blockerTaskVersionId and the blocked task with blockedTaskId, blockedShortId or blockedTaskVersionId; at least one per side is required (shortId wins over taskId, which wins over taskVersionId). Pass action "remove" to unlink. Links that would create a loop are rejected. A task that does not exist or is not yours is a TASK_NOT_FOUND error, and an argument this tool does not declare is refused as INVALID_INPUT.
• append_task_note — write · tasks:write — Add one entry to the END of a task’s notes: what you did, found or decided, and what comes next. The entry gets a dated header naming the workspace member and, when you pass author, the agent (for example "2026-10-22 15:04Z · Aladdin via Claude Code"); nothing already in the notes is changed. Use this instead of update_task to log progress or hand work over: you do not have to read the whole note first, and two agents writing to the same task at once never overwrite each other, so the log is shared across every chat. Use update_task only to rewrite the notes on purpose. To make a retry safe, pass idempotencyKey (a fresh value, such as a UUID, per entry) and resend the same key if a call times out: an entry already added under that key is not added again, and the result says changed: false. Identify the task with taskId (the id list_tasks and create_task return), shortId (e.g. 123 for T-123) or taskVersionId; at least one is required, and shortId wins over taskId, which wins over taskVersionId. A task that does not exist or is not yours is a TASK_NOT_FOUND error, and an argument this tool does not declare is refused as INVALID_INPUT.
• archive_task — write · tasks:write — Archive or unarchive a task. Archived tasks are hidden from the main task list. Identify the task with taskId (the id list_tasks and create_task return), shortId (e.g. 123 for T-123) or taskVersionId; at least one is required, and shortId wins over taskId, which wins over taskVersionId. A task that does not exist or is not yours is a TASK_NOT_FOUND error, and an argument this tool does not declare is refused as INVALID_INPUT. Asks for confirmation once: the first call is refused with CONFIRMATION_REQUIRED and a confirmToken; tell the user what it will do, then call again with that token.
• assign_task — write · tasks:write — Assign a task to a workspace member by name or userId, or unassign it. Accepts assigneeName (case-insensitive match against the workspace roster) OR assigneeUserId (from list_members). If the name matches more than one member the call is refused and names them so the agent can pick. Pass null for both to unassign. Identify the task with taskId, shortId or taskVersionId.
• claim_task — write · tasks:write — Claim a task for this agent session before working on it, so other agents (and people) see it is taken and do not start the same work. Pass agent, a name for THIS session that stays the same across your calls (for example "Claude Code · billing lane"). The claim is a lease that ends after minutes (default 60, max 1440): call again with the same agent to renew it, and call release_task when you finish or stop. If another agent already holds a live claim the call does NOT take it: it answers claimed false and names the holder and when the claim ends, so pick other work (list_tasks with unclaimedOnly: true) or coordinate. Pass force: true only to take over a claim you know is abandoned. A claim belongs to the connection that made it: only that same connection, with the same agent name, renews or releases it, so typing the name of another agent does not make its claim yours. Every claim reads back with via (the agent app that made it) and yours (true when it was made through this connection). Identify the task with taskId, shortId or taskVersionId.
• release_task — write · tasks:write — Release the claim this agent session holds on a task (see claim_task), so other agents can pick it up. Pass the same agent name you claimed it with, through the same connection. A claim held by a different agent (another name, or the same name on another connection) is left in place and the call says who holds it, unless you pass force: true. Releasing a task nobody holds is a no-op. Identify the task with taskId, shortId or taskVersionId.
• create_project — write · projects:write — Create a project in the workspace — a named grouping of tasks, shown down the side of the task list. Returns the new project id to pass as projectId on create_task, update_task or list_tasks. Project names are unique per workspace: if a project with that name already exists (archived or not) the call is refused and names the existing project and its id, so reuse it instead of creating a duplicate.
• update_project — write · projects:write — Rename a project or change its description. Identify the project by its id from list_projects; pass description null to clear it. A name already used by another project in the workspace is refused.
• archive_project — write · projects:write — Archive or unarchive a project. An archived project is hidden from project lists and pickers and no new task can be filed into it; the tasks already in it are left exactly as they are. Pass archived false to unarchive. Identify the project by its id from list_projects (pass includeArchived there to find an archived one). Asks for confirmation once: the first call is refused with CONFIRMATION_REQUIRED and a confirmToken; tell the user what it will do, then call again with that token.
• list_notes — read · tasks:read — List the shared notes of the workspace: documents every member and every connected agent reads and writes, not tied to one task (conventions, decisions, runbooks, handover logs). Read this at the start of a session to pick up what other chats already know. Each note carries only the start of its text (preview) and its full length, so the list stays cheap to read; call get_note for the full text of one note. Archived notes are left out unless you pass includeArchived: true. Results are paged, by title (limit, default 50, max 200): while nextCursor is not null, call again with cursor set to it and the same other arguments to get the rest.
• get_note — read · tasks:read — Get the FULL text of one shared workspace note, with its updatedAt (pass it back as baseUpdatedAt when you rewrite the note with update_note). Identify the note with noteId (from list_notes or create_note) or its exact title. A note that does not exist or is not in a workspace you can use is a NOTE_NOT_FOUND error.
• create_note — write · tasks:write — Create a shared workspace note that every member and every connected agent can read: a convention, a decision, a runbook or a handover log. Optionally file it under a project (an id from list_projects). Note titles are unique per workspace: if a note with that title already exists the call is refused and names it, so read it with get_note or add to it with append_note instead of creating a duplicate.
• append_note — write · tasks:write — Add one entry to the END of a shared workspace note: what you did, found or decided. The entry gets a dated header naming the workspace member and, when you pass author, the agent; nothing already in the note is changed. You do not have to read the whole note first, and two agents appending at once never overwrite each other. Identify the note with noteId or its exact title. A note that does not exist or is not in a workspace you can use is a NOTE_NOT_FOUND error.
• update_note — write · tasks:write — Rewrite a shared workspace note: its title, its WHOLE text, its project, or archive or unarchive it. Pass baseUpdatedAt, the updatedAt of the note as you last read it; if someone changed the note since, the update is refused so you can re-read it and apply your change again instead of overwriting their edit. To add to a note, use append_note instead. A note that does not exist or is not in a workspace you can use is a NOTE_NOT_FOUND error.
• list_recent_activity — read · tasks:read — See what happened in the workspace recently: the last task changes across all members and agents, newest first. Each entry names the task (shortId + name), what changed (status, priority, name, notes), who did it and when, and how (session, API key or OAuth client). Use this at the start of a session to catch up on what other agents and people have been doing, or to detect conflicts before editing a task someone else just changed. Returns at most limit entries (default 20, max 100).
• search_docs — read · workspaces:read — Search the GetItDone developer documentation — REST API operations, error/problem codes, and guide pages — and return ranked results with their public URLs. Guide and error pages also return a Markdown-twin URL (the page URL plus '.md') the agent can fetch to read the full page as plain text. Use when you need to know how a /v1 endpoint works, what an error code means, or where a capability is documented.
• billing_status — read · usage:read — Show the billing state of a workspace: plan, subscription status, seats, renewal or trial end date, whether the subscription is set to cancel, and the plan limits. Pass workspaceId from list_workspaces when the connection reaches several workspaces.
• list_plans — read · usage:read — List the plans (FREE, PRO, TEAM) with monthly and annual USD prices. Pass a returned plan id as plan, with a billing cycle, to upgrade_plan.
• get_usage — read · usage:read — Show the workspace consumption against its plan for the current billing period: API calls used, limit and remaining, plus the billing period dates.
• upgrade_plan — write · usage:read — Start an upgrade for a workspace. Returns a single-use link (valid 15 minutes, tied to this account) that opens the checkout already filled in: the user confirms payment there with one click. Card details are never entered in chat. Needs the workspace owner or an admin. Ask the user which plan and which billing cycle they want; never choose for them.
• manage_subscription — write · usage:read — Manage the workspace subscription. action "cancel" stops renewal at the end of the paid period and "refund" refunds the last payment and removes paid access now; both ask for confirmation first. action "extend" is always refused and points to upgrade_plan, because an agent cannot extend a paid period for free. action "portal" (also used for "resume", which the payment provider only offers in its portal) returns a single-use link to the billing portal. A subscription billed by an app store can only be changed by that store, so the tool returns the link to it. Pass an optional reason to record why the user is leaving.
• get_profile — read · workspaces:read — Show the signed-in account profile: name, email, job title, whether tips and prompts are shown, the preferred workspace and when the account was created.
• update_profile — write · workspaces:read — Change the account display name and job title. Only the fields you pass change; pass jobTitle null to clear it. The email address is not changed by this tool, and the profile photo is changed with update_profile_photo.
• get_notification_prefs — read · workspaces:read — Show the account reminder settings: whether the daily reminder is on, its time and time zone, and whether email and Slack notifications are enabled.
• update_notification_prefs — write · workspaces:read — Set the account reminder settings: isReminderEnabled, reminderTime as HH:MM in 24 hours, an optional IANA reminderTimezone, and the optional emailEnabled and slackEnabled channel switches (left unchanged when omitted).
• set_preferred_workspace — write · workspaces:read — Choose which workspace opens first for this account. Pass a workspaceId from list_workspaces; the account must be a member of it.
• set_prompt_preferences — write · workspaces:read — Turn the tips and prompts shown in the product on or off for this account.
• export_data — write · workspaces:read — Export what the account holds: the profile and the workspaces inline, plus a single-use download link per workspace for its active tasks as CSV. The links are valid 15 minutes and tied to this account.
• delete_account — write · workspaces:read — Permanently delete this GetItDone account. Refused with the reasons while the account is the only owner of a shared workspace. Cancels the subscription of every workspace it deletes; a plan bought through Apple, Google or Amazon cannot be cancelled here, so the result then carries storeNotice, plain text to pass on to the user. Asks for confirmation first. There is no undo from chat; contact support to restore from backup.
• list_sign_in_methods — read · workspaces:read — List the ways into this account: Google, Apple, GitHub and email and password, each connected or not. A connected method shows whether it can be disconnected; the last one never can. Connecting a method happens in the browser, so the result carries connectUrl, the Settings tab to open.
• disconnect_sign_in_method — write · workspaces:read — Disconnect one sign-in method from this account. Pass provider from list_sign_in_methods (google, apple, github, or credential for email and password). Refused while it is the only way left to sign in. It can be connected again later. Asks for confirmation first.
• create_team — write · members:read — Create a new workspace (team) owned by the user. Pass isPersonal true for a personal workspace that takes no invitations. Returns the new workspace with its id.
• update_team — write · members:read — Rename a workspace. Only the workspace owner can do this. Pass workspaceId from list_workspaces when the connection reaches several workspaces.
• delete_team — write · members:read — Permanently delete a workspace and all of its tasks, projects, notes and attachments. Only the owner can do this. Needs confirmationName, the exact workspace name, which the user must type; never fill it in on their behalf. Cancels the workspace subscription first; a plan bought through Apple, Google or Amazon cannot be cancelled here, so the result then carries storeNotice, plain text to pass on to the user. Asks for confirmation first. There is no undo from chat; contact support to restore from backup.
• list_invites — read · members:read — List the invitations of a workspace with their email, status and expiry. Needs the workspace owner or an admin.
• invite_member — write · members:read — Invite a person to a workspace by email. They get an email with a link to join as a member; promote them afterwards with update_member_role. Needs the workspace owner or an admin, and a plan with room for another member.
• resend_invite — write · members:read — Send a pending invitation email again and restart its lifetime. Pass invitationId from list_invites.
• revoke_invite — write · members:read — Withdraw an invitation so its link stops working. Pass invitationId from list_invites.
• remove_member — write · members:read — Remove a person from a workspace. Only the owner can do this, and the owner cannot remove themselves. Pass userId from list_members. Their invitations to the workspace are withdrawn. Asks for confirmation first.
• update_member_role — write · members:read — Make a member an admin, or an admin a member again. Only the owner can change roles; the owner role itself cannot be granted or changed here. Pass userId from list_members.
• create_support_ticket — write · workspaces:read — Send a support request to the GetItDone team on the user's behalf: a bug, a feature request, a question or anything else. Replies come to the user's email. Attachments are links to files the user already shared. Returns a ticket id. Limited to a few requests every ten minutes.
• list_support_tickets — read · workspaces:read — List the support tickets filed through this tool for the signed-in account, newest first, with their type, subject and date. Tickets sent through the web form are not listed.
• list_connections — read · workspaces:read — List the integrations of a workspace (Slack, GitHub, ClickUp, Monday) with their status (ACTIVE, INACTIVE, ERROR or NOT_CONNECTED), when they were connected and who installed them.
• get_connect_links — write · workspaces:read — Get single-use links (valid 15 minutes, tied to this account) that open the provider's own approval page to connect Slack, GitHub, ClickUp or Monday to a workspace. The user approves the connection there themselves. Pass provider for one link, or leave it out for all four. Needs the workspace owner or an admin.
• disconnect_integration — write · workspaces:read — Disconnect an integration (Slack, GitHub, ClickUp or Monday) from a workspace and clear its stored token. For Slack the bot token is also revoked at Slack. Imports and syncs stop. Needs the workspace owner or an admin. Asks for confirmation first.
• reverify_integration — read · workspaces:read — Check that a connected integration still works by making a live call with its stored token. Returns connected true or false with the reason when it fails. If it fails, ask the user to connect again with get_connect_links.
• list_integration_containers — read · projects:read — List the ClickUp lists or Monday boards that can be bound to a project of the workspace. Needs that integration to be connected.
• list_integration_bindings — read · projects:read — List the projects of the workspace that are bound to a ClickUp list or a Monday board, with the bound container.
• save_integration_binding — write · projects:write — Bind a project to a ClickUp list or a Monday board so its items can be imported. Take the container fields from list_integration_containers. ClickUp needs listId, listName, teamId, teamName, spaceId and spaceName (folderId and folderName are optional). Monday needs boardId and boardName (statusColumnId, dueDateColumnId, priorityColumnId and assigneeColumnId are optional). Needs the workspace owner or an admin.
• remove_integration_binding — write · projects:write — Remove the binding between a project and a ClickUp list or Monday board. Items already imported stay; new imports for that project stop. Pass bindingId from list_integration_bindings. Needs the workspace owner or an admin. Asks for confirmation first.
• list_import_jobs — read · projects:read — List the recent ClickUp or Monday import jobs of the workspace with their status and counts.
• start_integration_import — write · projects:write — Start importing the items of the ClickUp list or Monday board bound to a project into that project. Optional maxItems (1 to 5000) and updatedSince (YYYY-MM-DD) limit the import. An import already running for the project is reused. Needs the workspace owner or an admin. Check progress with list_import_jobs.
• list_github_repos — read · tasks:read — List the GitHub repositories reachable through the workspace's GitHub connection, with name, visibility, default branch and last push.
• get_github_activity — read · tasks:read — Get the signed-in user's GitHub commits and pull requests for one date (YYYY-MM-DD), grouped by repository, through the workspace's GitHub connection.
• generate_daily_from_github — write · tasks:write — Turn the signed-in user's GitHub activity for one date (YYYY-MM-DD) into entries of their daily plan. Only for the user's own daily plan.
• list_api_keys — read · workspaces:read — List the API keys of a workspace with their name, key prefix, permissions, last use and expiry. The secret is never shown. Needs the workspace owner or an admin to see the workspace keys.
• create_api_key — write · api-keys:manage — Create an API key for a workspace. The key is returned once, so tell the user to store it. Pass tiers to limit what the key may do (read, write, destructive, billing, account, team, connections, support, keys); leave it out for every tier this connection holds. A key can never hold a permission this connection does not hold. Needs the workspace owner or an admin.
• rotate_api_key — write · api-keys:manage — Replace an API key with a new one that has the same name and permissions. The old key keeps working for the overlap you choose (now, 1h, 24h, 3d or 7d) so clients can switch over; now ends it immediately. The new key is returned once. Pass keyId from list_api_keys. Needs the workspace owner or an admin.
• revoke_api_key — write · api-keys:manage — Revoke an API key so it stops working. Pass keyId from list_api_keys. Needs the workspace owner or an admin. Asks for confirmation first.
• list_connected_apps — read · workspaces:read — List the AI apps connected to the signed-in account with the permission tiers each holds, and the apps an account recovery paused. Pass a returned connection id to revoke_connected_app, or a paused clientId to reenable_connected_app.
• revoke_connected_app — write · workspaces:read — Disconnect an AI app from the account; it loses access immediately and has to be approved again. If it is the app you are talking through, the conversation loses access too. Pass connectionId from list_connected_apps. Asks for confirmation first.
• reenable_connected_app — write · workspaces:read — Turn back on an AI app that an account recovery paused. The connections it had stay revoked, so the app has to be approved again. Pass clientId from the pausedApps of list_connected_apps.
• list_granted_scopes — read · workspaces:read — Show what this connection may do: the permission tiers and API scopes it holds, the app it is, and which workspaces it reaches. Call it before an action that was refused for a missing permission.
• request_scopes — write · workspaces:read — Ask the user to approve more permission for this connection. Returns a single-use link (valid 15 minutes, tied to this account) where the user ticks and approves the tiers; the new permission applies right away after they approve. Works for a connection made by signing in. A connection made with an API key cannot be widened; create a new key with create_api_key instead.
• get_daily_plan — read · tasks:read — Read one board day for the current user. Returns both sections of that date: PROGRESS, shown on the board as "Today's Progress" (what is being worked on that day), and TODO, shown as "Tomorrow's Plan" (what is lined up for the day after). Pass the date the user is asking about; omit it for today.
• add_task_to_daily — write · tasks:write — Put an existing task on a board day. Find the task with list_tasks first and use its shortId; create a new task only when none matches. dailyType PROGRESS is the "Today's Progress" column for work happening on that date. dailyType TODO is the "Tomorrow's Plan" column for work lined up for the day after, so planning something for tomorrow is dailyType TODO with date left as today. Only pass date when the user names another board day.
• remove_task_from_daily — write · tasks:write — Take a task off a board day, out of one section: PROGRESS ("Today's Progress") or TODO ("Tomorrow's Plan"). The task itself is not deleted and can be put back with add_task_to_daily. The date is the board date whose section is edited.
• update_daily_status — write · tasks:write — Set the status of one section on a board day: mark PROGRESS ("Today's Progress") COMPLETED when the day's work is done, or TODO ("Tomorrow's Plan") PLANNED once the next day is lined up.
• accept_daily_suggestion — write · tasks:write — Accept a suggested task on a board day, which moves it from the suggestions into the chosen section. Pass the task shortId, the dailyType of the section, and optionally the board date (defaults to today).
• dismiss_daily_suggestion — write · tasks:write — Dismiss a suggested task so it stops being suggested for that section. Pass the task shortId and the dailyType of the section.
• set_task_recurrence — write · tasks:write — Make a task repeat on a schedule, replacing any existing one. Completed days are never rewritten. Name the task with shortId, taskId or taskVersionId. create_task and update_task set the same schedule through their recurrence field.
• clear_task_recurrence — write · tasks:write — Stop a task repeating. Days already completed are kept, so streaks and history survive. Name the task with shortId, taskId or taskVersionId.
• list_task_occurrences — read · tasks:read — List the days of a repeating task, newest first, with each day's status (open, completed or skipped). Name the task with shortId or taskVersionId. Pass from and to as YYYY-MM-DD to narrow the range; limit defaults to 120.
• skip_task_occurrence — write · tasks:write — Skip one DAY of a repeating task: it was not done and will not be. The day is closed rather than rolled over, and the rest of the schedule is untouched. Name the task with shortId, taskId or taskVersionId, and the day with occurrenceDate (YYYY-MM-DD; defaults to today).
• delete_task — write · tasks:write — Permanently delete a task and all of its versions. This cannot be undone; archive_task hides a task and can be reversed, so prefer it unless the user clearly wants the task gone. Name the task with shortId, taskId or taskVersionId. Asks for confirmation first.
• bulk_archive_tasks — write · tasks:write — Archive or unarchive up to 100 tasks at once by their shortIds. Pass archived true to archive and false to bring them back. Tasks that are not found are listed in notFound and nothing else is affected. Asks for confirmation first.
• get_task_history — read · tasks:read — Read the change history of a task: every saved version (newest first, the latest 100) with who changed it, when, and which fields changed, plus subtask activity. Notes and description are not repeated in every version: a version that changed the notes lists the dated entries it added or removed as one-line outlines (stamp, author, size, first words), and the current notes come from get_task_details, which reads one entry when its stamp is passed as both notesSince and notesUntil. Name the task with shortId, taskId or taskVersionId.
• export_tasks — read · tasks:read — Export the workspace's active tasks as CSV with status, priority, due date, story points, logged hours, owner, projects and notes. A small export comes back inline in csv; a large one comes back as a single-use download link in download that the user opens.
• parse_quick_add — read · tasks:read — Parse one typed line such as "Pay rent every month on the 1st !high #Home" into a task draft with name, priority, due date, start date, project names and recurrence. Nothing is created; pass the draft fields to create_task. today is the user's current date as YYYY-MM-DD; leave it out for the server date.
• get_task_totals — read · tasks:read — Read the logged time of a task: total spent hours and who logged them. Name the task with shortId, taskId or taskVersionId.
• list_task_attachments — read · tasks:read — List the files attached to the current version of a task with each file's id, name, type, size and date. Name the task with shortId, taskId or taskVersionId. Pass an id to get_attachment_download_url or delete_attachment.
• attach_file — write · tasks:write — Attach a file to a task from a public https link. The server downloads the file, checks it against the plan's file size and storage limits, and adds it to the task; a link that redirects, needs a login, or points at a private address is refused, so give the final public link. Name the task with shortId, taskId or taskVersionId. fileName is optional and defaults to the name in the link. Files up to 50 MB can be attached this way.
• get_attachment_download_url — read · tasks:read — Get a short-lived download link for one attachment. The link works without signing in until it expires, so share it only with the user. Pass attachmentId from list_task_attachments.
• delete_attachment — write · tasks:write — Remove a file from a task's current version. Earlier versions of the task keep their copy in the history. Pass attachmentId from list_task_attachments. Asks for confirmation first.
• list_webhook_endpoints — read · webhooks:read — List the workspace's outbound webhook endpoints with url, enabled state, subscribed event types and whether the endpoint is verified. entitled is false when the plan does not include webhooks.
• create_webhook_endpoint — write · webhooks:write — Add an outbound webhook endpoint. The url must be a public https address on the standard port; private and internal addresses are refused. eventTypes picks task.created, task.updated and task.archived; leave it out for all. The signing secret is returned once, so tell the user to store it, then run verify_webhook_endpoint. Needs a Pro plan or above and the workspace owner or an admin.
• update_webhook_endpoint — write · webhooks:write — Change an endpoint's url, subscribed event types or enabled state. A new url has to be verified again. Enabling an endpoint clears an automatic disable. Pass endpointId from list_webhook_endpoints. Needs the workspace owner or an admin.
• delete_webhook_endpoint — write · webhooks:write — Delete a webhook endpoint together with its queued deliveries and delivery history. This cannot be undone; update_webhook_endpoint with enabled false pauses it instead. Pass endpointId from list_webhook_endpoints. Needs the workspace owner or an admin. Asks for confirmation first.
• rotate_webhook_secret — write · webhooks:write — Issue a new signing secret for an endpoint. The new secret is returned once; the old one keeps verifying signatures for 24 hours so the receiver can switch over. Pass endpointId from list_webhook_endpoints. Needs the workspace owner or an admin.
• verify_webhook_endpoint — write · webhooks:write — Send a signed verification request to the endpoint now and mark it verified when it answers with success. Returns verified, the status the receiver answered and the reason when it failed. Pass endpointId from list_webhook_endpoints. Needs the workspace owner or an admin.
• send_webhook_test_event — write · webhooks:write — Send one signed sample event to the endpoint now and report how the receiver answered. Nothing is queued and the delivery log is not touched. eventType defaults to task.created. Pass endpointId from list_webhook_endpoints. Needs the workspace owner or an admin.
• list_webhook_deliveries — read · webhooks:read — Read the newest 50 deliveries to an endpoint with their state, attempts, last status and last error. Pass onlyFailed true to see only failed ones, then replay_webhook_delivery or replay_failed_webhooks. Pass endpointId from list_webhook_endpoints.
• replay_webhook_delivery — write · webhooks:write — Queue one past delivery to be sent again. Pass endpointId from list_webhook_endpoints and deliveryId from list_webhook_deliveries. Needs the workspace owner or an admin.
• replay_failed_webhooks — write · webhooks:write — Queue every failed delivery to an endpoint since a point in time to be sent again, up to 1000 per call. since is an ISO 8601 date and time such as 2026-10-27T00:00:00Z. Returns replayedCount. Pass endpointId from list_webhook_endpoints. Needs the workspace owner or an admin.
• get_referral_info — read · workspaces:read — Read the signed-in person's Refer and Earn state: their personal referral link, its click, sign-up and sale counts, and pending, cleared and paid earnings in US cents. Earnings belong to one person, so this works for a connection made by signing in and is refused for an API key. enabled is false for a guest account or when the program is not set up.
• list_api_request_log — read · usage:read — Read the workspace's API request log, newest first: when, which key or app, the operation, the status and how long it took. Pass onlyErrors true for failures, credentialKey to follow one key, or requestId for one request. limit defaults to 50 and is at most 100; while hasMore is true call again with cursor set to nextCursor and the same other arguments.
• get_api_usage_by_key — read · usage:read — Show this billing period's API calls for the workspace split by key or app: calls used, the plan limit, what remains, the burst limit per minute and the calls each key made. get_usage gives the plan totals without the split.
• delete_project — write · projects:write — Delete a project for good. Its tasks are kept and only lose this project; pass reassignProjectId, a project of the same workspace from list_projects, to move them there first. archive_project hides a project and can be reversed, so prefer it unless the user wants the project gone. Asks for confirmation first.
• update_profile_photo — write · workspaces:read — Set the account profile photo from a public https link to a PNG, JPEG, WebP or GIF image. The server downloads it, checks the size and the real image type, and stores it; a link that redirects, needs a login or points at a private address is refused, so give the final public link.

Context other task tools don't give an AICopy Anchor Link

Most task-management MCP integrations stop at text and metadata. GetItDone treats the AI as a first-class user and hands it the same rich context a teammate would get:

• Full task contents, attachments included. get_task_details returns a task's rich-text notes plus every attachment — images, videos, documents — each with a short-lived URL the assistant can fetch to read the actual content, not just a filename.
• Blocked-by chains the assistant can read and write. list_tasks reports whether each task is currently blocked and how many tasks it blocks, get_task_details returns the chain in both directions, and link_task_dependency records or removes a blocker — so "what can I actually start today?" is answered from the real graph, and a link that would create a loop is refused rather than stored.
• Video-frame extraction, server-side. get_task_video_context samples evenly-spaced frames from screen recordings and other videos attached to a task. Through Code Mode, which the server uses, the assistant receives a summary (how many frames each video gave and whether extraction worked), not the frame images. YouTube and Vimeo links in the notes are surfaced too.

QuotasCopy Anchor Link

The MCP server works on every plan, including Free. MCP requests made with a gid_ API key count against the same workspace API-call quota as the REST API, one per request. Apps connected by signing in (OAuth), such as Claude, are not metered against that quota. The per-plan numbers are in Rate limits & quotas, and checkout is on the pricing page.

FAQCopy Anchor Link

What is the GetItDone MCP server?Copy Anchor Link

It is a remote Model Context Protocol server at https://app.nowgetitdone.com/api/mcp. AI assistants use it to list, create, update, complete and archive your GetItDone tasks, and to read what is inside them: notes and attachments. There is nothing to install.

Which AI assistants can connect to GetItDone?Copy Anchor Link

Any MCP client that supports remote servers over Streamable HTTP with OAuth sign-in: Claude (claude.ai, Claude Desktop and Claude Code), ChatGPT and Codex, Cursor, VS Code with GitHub Copilot, Google Antigravity, Gemini, Kiro, Perplexity, Mistral Le Chat, Grok, Replit, Windsurf, Zed, Cline and others. Clients that take a JSON config with headers can connect with an API key instead of signing in.

Do I need an API key to connect an AI assistant?Copy Anchor Link

Not if your client can sign in. Claude and Claude Code use OAuth: you approve access on a GetItDone consent screen and never handle a key. Create a gid_ key under Profile → API Keys only for clients that take a JSON config with headers.

Is the GetItDone MCP server free?Copy Anchor Link

Yes. It works on every plan, including Free. MCP requests made with a gid_ API key count against your workspace's API-call quota, the same quota as the REST API; apps connected by signing in are not metered.

Can an AI assistant delete my tasks?Copy Anchor Link

No. There is no delete tool. With write access an assistant can create, update, complete, link and archive tasks, and an archived task can be unarchived.

What can an AI see in GetItDone that other task tools don't show it?Copy Anchor Link

The contents of a task, not just its title: rich-text notes, every attachment through a short-lived URL, a summary of the frames extracted from screen recordings, and the blocked-by chain between tasks. See Context other task tools don't give an AI.