Hosted Taskade MCP

Connect Claude, Codex, Cursor, VS Code, ChatGPT, or any MCP client to your Taskade workspace through the hosted server at https://www.taskade.com/mcp. You install nothing: add the URL, sign in, and your client can work with projects, tasks, agents, and Taskade Genesis app source.

Page type: How-to guide. Use it when you know the goal and need the steps.

TL;DR: Add https://www.taskade.com/mcp to your MCP client and sign in with Taskade. The workspace must be on a paid plan (Starter and above). For a local server that wraps REST API v1, see Workspace MCP.

┌──────────────────────────────┐
│  Your MCP client             │
│  Claude · Codex · Cursor     │
└──────────────┬───────────────┘
               │  1. Add the URL
               ▼
┌──────────────────────────────┐
│  Taskade sign-in (OAuth)     │
│  or a personal access token  │
└──────────────┬───────────────┘
               │  2. Call list_spaces
               ▼
┌──────────────────────────────┐
│  Your paid workspaces        │
│  projects · tasks · agents   │
│  automations · app/ source   │
└──────────────────────────────┘

This is the inbound direction: an AI client reaches into Taskade. For Taskade calling another MCP server, see Which Taskade MCP do I want?.

Before you start

Check the plan, your role, and your client before you connect.

Your workspace role sets what each tool can do:

Note: Taskade adds tools as the Action API v2 grows, so the tool list can change. Your client shows the current list after it connects.

Server details

Every client uses the same endpoint and the same two sign-in options.

What you can do

A connected client can read your workspace and make changes in it.

What the hosted server cannot do

Some work stays in the Taskade app or in another API.

For a Taskade EVE job, the client can write the request for the user to paste into Taskade EVE.

Connecting your client

Pick your client below. Each section gives the exact config or command, then the sign-in step.

Tip: Settings → API → MCP connection in Taskade has Copy MCP URL, Add to Cursor, and Add to VS Code. Under Advanced: use a personal access token, Connect Cursor and Connect Claude copy a JSON config with a personal access token placeholder.

Claude (desktop and web)

Claude adds remote MCP servers as custom connectors. OAuth runs in your browser.

1. In Claude, open Settings → Connectors.
2. Click Add custom connector.
3. Type Taskade as the name. Paste https://www.taskade.com/mcp as the URL. Click Add.
4. Click Connect, then sign in to Taskade and allow access.

The Claude labels can change between releases. If you do not see Connectors, search the Claude help for "custom connectors".

Claude Code

Install the Taskade plugin. It adds the server and the Taskade skills, which tell Claude which tool fits each job.

claude plugin marketplace add taskade/mcp
claude plugin install taskade@taskade

The same plugin installs in other agent hosts:

Any other agent can read the Taskade skill at https://www.taskade.com/SKILL.md. Taskade also publishes an agent skills index at https://www.taskade.com/.well-known/agent-skills/index.json, so this command installs the skill:

npx skills add https://www.taskade.com

The skill also tells the agent how to read any Taskade page as Markdown. The agent sends Accept: text/markdown to the normal page URL.

To add only the server, run one command:

claude mcp add --transport http taskade https://www.taskade.com/mcp

In Claude Code, type /mcp, select the Taskade server, and sign in. To share the server with your team, commit this .mcp.json file at the root of the repository:

{
  "mcpServers": {
    "taskade": {
      "type": "http",
      "url": "https://www.taskade.com/mcp"
    }
  }
}

Codex

Codex connects to the hosted server over Streamable HTTP and signs in with OAuth. Add the server, then sign in:

codex mcp add taskade --url https://www.taskade.com/mcp
codex mcp login taskade

The login command opens Taskade in your browser. Sign in and allow access. To install the Taskade skills too, use the Codex plugin command in the Claude Code section.

Cursor

Cursor reads MCP servers from ~/.cursor/mcp.json (all projects) or .cursor/mcp.json (one project).

{
  "mcpServers": {
    "taskade": {
      "type": "http",
      "url": "https://www.taskade.com/mcp"
    }
  }
}

Save the file. Open Cursor's MCP settings, find taskade, and sign in when Cursor asks.

VS Code

VS Code reads MCP servers from .vscode/mcp.json in your workspace. The key is servers, not mcpServers.

{
  "servers": {
    "taskade": {
      "type": "http",
      "url": "https://www.taskade.com/mcp"
    }
  }
}

You can also add the server from a terminal:

code --add-mcp '{"name":"taskade","type":"http","url":"https://www.taskade.com/mcp"}'

Start the server from mcp.json, and sign in when VS Code asks. Use the Taskade tools in Copilot Chat agent mode.

ChatGPT

ChatGPT connects to a remote MCP server as a custom connector in developer mode. It uses OAuth only.

1. In ChatGPT settings, turn on developer mode for apps and connectors.
2. Create a connector. Type Taskade as the name and https://www.taskade.com/mcp as the server URL.
3. Select OAuth as the authentication. Sign in to Taskade and allow access.

Developer mode is available only on some ChatGPT plans, and the labels change often. If you cannot find it, search the ChatGPT help for "developer mode" and "connectors".

Windsurf

Windsurf reads MCP servers from ~/.codeium/windsurf/mcp_config.json. A remote server uses serverUrl.

{
  "mcpServers": {
    "taskade": {
      "serverUrl": "https://www.taskade.com/mcp"
    }
  }
}

If Windsurf does not open a sign-in page, add the headers block from "Other clients" below.

Other clients

Any client that can send a request header connects with a personal access token. This is the config that Taskade copies from Settings → API → MCP connection → Advanced: use a personal access token:

{
  "mcpServers": {
    "taskade": {
      "type": "http",
      "url": "https://www.taskade.com/mcp",
      "headers": {
        "Authorization": "Bearer <paste-your-token-here>"
      }
    }
  }
}

Warning: Treat a config file that holds a token as a secret. Do not commit it. The token can do everything that your account can do.

A client that runs only local stdio servers can reach the hosted server through the mcp-remote bridge. It runs OAuth in your browser:

{
  "mcpServers": {
    "taskade": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://www.taskade.com/mcp"]
    }
  }
}

Scripts, CI jobs, and agent frameworks cannot open a browser. Send Authorization: Bearer $TASKADE_TOKEN with a personal access token. See Use a personal token with hosted MCP.

First-time OAuth authentication

An interactive client signs in once, then keeps the token. The client does the OAuth work, and you only sign in and allow access:

  Your MCP client            taskade.com                 You
  ───────────────            ───────────                 ───
  Connect to /mcp,  ──────▶  401 + OAuth metadata URL
  no token
  Register, start   ──────▶  Sign-in and consent  ─────▶ Sign in,
  sign-in                    page                        allow access
                    ◀──────  Access token with
                             the mcp scope
  Call list_spaces  ──────▶  Your paid workspaces
  with the token

1. Add the server URL to your client.
2. Follow the browser redirect to Taskade.
3. Sign in with the Taskade account that can open the target workspace.
4. Allow MCP access to your account.
5. Go back to your client. It stores the token.

Do this once for each client.

Confirm it worked

Ask your client for a first read. A good first prompt:

Use the Taskade tools to list my workspaces. For each one, show the name and my role. Do not change anything.

You are done when the client calls list_spaces and shows your paid workspaces. The list comes in pages, and a page can be empty while more pages remain. If no page lists a workspace, no workspace of this account has MCP access.

Note: A HEAD request or curl -I to https://www.taskade.com/mcp returns 401 with content-type: application/json and a WWW-Authenticate: Bearer header. That response is expected, because the probe sends no token. Do not change the server URL.

The MCP toolset

The tables below list every tool that the hosted server exposes: workspace, project, task, agent, automation, app-editing, and app kit tools. The server also exposes a taskade://getting-started resource that an MCP client can read as a quickstart.

Most tools mirror an Action API v2 operation. The MCP-native tools are inspect_space, read_project, list_automations, write_file, run_flow, get_flow_runs, list_my_kits, and publish_kit_version.

Every tool states the MCP hints readOnlyHint, destructiveHint, and openWorldHint. A client can use the hints to approve read tools without a prompt and to ask before a write. Three tools state openWorldHint: true, because their effects reach outside the workspace: prompt_agent, run_flow, and publish_kit_version.

The server also adds two Taskade keys to the _meta of a tool. A client that does not know them ignores them.

Most tools take a spaceId. Call list_spaces first to find it. That list is plan-filtered and paginated, so a page can be empty while more pages remain. Keep paginating until hasNextPage is false.

Browse & app editing

write_file refuses to delete a file while any app source still imports it. Remove or change those imports first. You can bring a deleted file back from the app's Version History.

Read workspace data

Task writes

These tools mirror the Action API v2 task operations:

If Google Calendar is connected on an eligible workspace, dates set with set_task_date can sync the same way as dates set in Taskade.

Create & orchestrate

If the new agent must read or change project data, pass "enableProjectTool": true to create_agent.

You can change this setting later with update_agent. This setting also enables the required knowledge support.

Run automations

run_flow starts a real run. The run counts toward the monthly automation runs of the plan, and AI steps use credits. A step can also send email or act in a connected app. Call it once for each run that you want.

run_flow returns before the run ends. Call get_flow_runs to read the result. A run status is running, waiting, completed, failed, or filtered. A waiting run is paused on an approval step until a person decides, or until the step times out. Its endedAt is null, the same as a running run. A filtered run stopped early on purpose and did not fail. If run_flow returns the status unknown, running, or waiting, do not start the run again. Read it with get_flow_runs.

App kits

An app kit is a Taskade Genesis app that you published so other people can add a copy. These tools release a new version of a kit from your MCP client:

Only the workspace owner can call publish_kit_version. list_my_kits lists kits from workspaces that you own, and it hides a kit whose workspace has no MCP access. Archived and removed kits are not listed.

publish_kit_version releases the app as it is now. People who add the kit from then on get this version, and people who already added it keep their copy. From version 2 on, buyers get one email a day at most. Only the newest 20 versions keep a saved copy, so each call removes the saved copy of an older version past that limit.

A paid kit keeps its price. You can publish 5 versions of one kit in an hour.

Project lifecycle

enable_share_link returns an error if the share link is already on, or if your email is not verified.

The virtual filesystem

inspect_space presents each workspace as a directory tree:

workspace/
├── app/            # Taskade Genesis app source (write_file can write here)
├── projects/       # Tasks and documents (read_project and list_tasks give structure)
├── agents/         # AI agent definitions
├── automations/    # Automations (read-only)
└── media/          # Uploaded files (read-only)

You can write files in the app/ directory only. Taskade rejects write_file against projects/, agents/, automations/, or media/. Use the structured tools in the earlier tables to create projects, edit tasks, and manage agents.

Example workflows

Each prompt below names the tools that the client calls.

Refactor a component with Claude

Open my "Landing Page" workspace, look at app/src/App.tsx, and split the hero section into its own component. Keep the existing styling.

The client calls list_spaces, inspect_space, then write_file two times: one new component file and one App.tsx update.

Stand up a project and brief an agent

Create a project called "Q3 Launch" with one task for each milestone in this outline. Attach it to my Research agent, then ask the agent to summarize the risks.

The client calls create_project, add_knowledge_project, and prompt_agent.

Audit your app for accessibility

Check every file in app/src/ for missing alt text, ARIA labels, and keyboard handlers. Suggest fixes, but do not apply them yet.

The client reads your files with inspect_space and shows a report before you approve any edit.

Tips and gotchas

These rules prevent most surprises.

• Read before you edit. Ask your client to inspect a file first. An edit against an old view can fail or give an unexpected result.
• One workspace at a time. Tools take a spaceId. Before you give a command, point your client at the right workspace.
• A write goes live. Each successful write_file commits the change and starts a new build. On a live app, the default setting publishes that build by itself. If the app owner chose Manual Updates, click Publish in Taskade to make the change live.
• prompt_agent runs the agent. It uses the agent's model and consumes AI credits. Treat it as a real prompt, not a preview. One account can send 60 prompts in 10 minutes, across all agents.

When to use MCP vs. Taskade EVE

Use Taskade EVE inside Taskade. Use MCP when you work in your own IDE or AI client.

Troubleshooting

Match the message that your client shows to a fix.

Read a tool error in code

A tool error is a result with isError: true. The text block holds the message from the table above. Many refusals also carry structuredContent.error, so a script or an agent can branch without a text match:

{
  "isError": true,
  "structuredContent": {
    "error": {
      "class": "rate",
      "code": "rate_limited",
      "message": "Too many agent prompts in a short time, so the agent did not run. Try again in about 3 min.",
      "retry": "after_wait",
      "retryAfterSec": 142
    }
  }
}

An error with no structuredContent.error is a general failure. Read its text.

Set this up with your coding agent

Paste this block into your coding agent to connect it.

Connect to the hosted Taskade MCP server at https://www.taskade.com/mcp over Streamable HTTP. If you support interactive sign-in, use OAuth 2.0 with PKCE and dynamic client registration. If you can only send headers, send "Authorization: Bearer <token>" with a personal access token from https://www.taskade.com/settings/api. The workspace must be on a paid Taskade plan. First call list_spaces and page until hasNextPage is false. Then call inspect_space on one workspace and report what you can see. Do not write anything until I confirm.

Next steps

• Which Taskade MCP do I want?: compare hosted MCP, local Workspace MCP, and the MCP Client connector.
• Workspace MCP: run a local server that wraps REST API v1.
• Run your live app with AI: run a Taskade Genesis app by talking to Claude.
• Action API guide: the API that most hosted MCP tools mirror.
• Authentication: personal tokens and OAuth 2.0 in detail.