Taskade MCP Server
by camilam044
README.md
<div align="center">
# Taskade MCP Server
**Connect [Taskade](https://www.taskade.com) to Claude, Cursor, VS Code, Windsurf and any other client of the [Model Context Protocol](https://modelcontextprotocol.io/).**
[](https://cursor.com/install-mcp?name=taskade&config=eyJ1cmwiOiJodHRwczovL3d3dy50YXNrYWRlLmNvbS9tY3AifQ%3D%3D)
[](https://vscode.dev/redirect/mcp/install?name=taskade&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fwww.taskade.com%2Fmcp%22%7D)
[](#claude-web-desktop-and-mobile)
[](https://www.npmjs.com/package/@taskade/mcp-server)
[](https://github.com/taskade/mcp)
[](https://github.com/taskade/mcp/blob/main/LICENSE)
**Hosted server:** `https://www.taskade.com/mcp` (Streamable HTTP, OAuth). Nothing to install.
</div>
This repo holds two packages:
- [MCP Server](https://github.com/taskade/mcp/tree/main/packages/server) (`@taskade/mcp-server`): the local stdio server, for clients that cannot connect to a remote server.
- [OpenAPI Codegen](https://github.com/taskade/mcp/tree/main/packages/openapi-codegen): generate MCP tools from any OpenAPI spec, not only Taskade.
---
## Contents
- [Quick Start: hosted server](#quick-start-hosted-server)
- [Hosted tools (48)](#hosted-tools-48)
- [Example prompts](#example-prompts)
- [Troubleshooting](#troubleshooting)
- [Local package (stdio)](#local-package-stdio)
- [Local package tools (62)](#local-package-tools-62)
- [Why Taskade MCP?](#why-taskade-mcp)
- [Agent Recipes](#agent-recipes)
- [OpenAPI Codegen](#openapi-codegen)
- [What is Taskade?](#what-is-taskade)
- [Privacy & Security](#privacy--security)
- [Support](#support)
- [Contributing](#contributing)
- [License](#license)
---
## Demo
MCP-powered Taskade agent running inside Claude Desktop by Anthropic:
| Build Agents via MCP | Automate Workflows | Manage Projects |
|:---:|:---:|:---:|
| <img src="https://raw.githubusercontent.com/taskade/taskade/main/media/agents/agent-generator.gif" width="280" alt="Create AI agents from your IDE via Taskade MCP"> | <img src="https://raw.githubusercontent.com/taskade/taskade/main/media/automations/automation-flows.gif" width="280" alt="Automate workflows via Taskade MCP"> | <img src="https://raw.githubusercontent.com/taskade/taskade/main/media/genesis/create-app.gif" width="280" alt="Manage projects and apps via Taskade MCP"> |
| Create, train, deploy AI agents from Claude/Cursor | Build multi-step automations across 100+ services | Full workspace management from your AI assistant *(paid plans)* |
---
## Quick Start: hosted server
| | |
|---|---|
| **URL** | `https://www.taskade.com/mcp` |
| **Transport** | Streamable HTTP |
| **Auth** | OAuth 2.0 with PKCE and dynamic client registration. Your client opens a Taskade sign-in page once. |
| **Plan** | MCP access is part of every paid Taskade plan (Starter and up). On the Free plan, `list_spaces` returns no workspaces. |
| **Discovery** | `https://www.taskade.com/.well-known/oauth-protected-resource/mcp` |
An `initialize` request without a token returns `401` on purpose. The `401` tells your client where to start the OAuth sign-in.
### Claude (web, Desktop and mobile)
1. In Claude, go to [**Customize > Connectors**](https://claude.ai/customize/connectors) and select **Add custom connector**. On a Team or Enterprise plan, an Owner first adds the connector in **Organization settings > Connectors** (**Add**, then **Custom**).
2. Enter the name `Taskade` and the URL `https://www.taskade.com/mcp`, then select **Add**.
3. Select **Connect**, sign in to Taskade, and approve access.
4. In a chat, select **+ > Connectors** and turn on Taskade.
If the dialog asks for an **OAuth client**, select **Register automatically**. The connector also works in Claude Desktop and the Claude mobile apps on the same account.
### Claude Code
```bash
claude mcp add --transport http taskade https://www.taskade.com/mcp
```
Then run `/mcp` in Claude Code and select **taskade** to sign in.
### Cursor
Select **Add to Cursor** at the top of this page, or add this to `~/.cursor/mcp.json`:
```json
{
"mcpServers": {
"taskade": {
"url": "https://www.taskade.com/mcp"
}
}
}
```
### VS Code
Select **Install in VS Code** at the top of this page, or run:
```bash
code --add-mcp '{"name":"taskade","type":"http","url":"https://www.taskade.com/mcp"}'
```
### Windsurf
Add this to `~/.codeium/windsurf/mcp_config.json`:
```json
{
"mcpServers": {
"taskade": {
"serverUrl": "https://www.taskade.com/mcp"
}
}
}
```
### Other clients and servers (API token)
A client that cannot do OAuth can send a Taskade personal access token as a Bearer token. Create the token in [Taskade Settings > API](https://www.taskade.com/settings/api).
```json
{
"mcpServers": {
"taskade": {
"type": "http",
"url": "https://www.taskade.com/mcp",
"headers": { "Authorization": "Bearer YOUR_TASKADE_API_TOKEN" }
}
}
}
```
Full guide: [Hosted Taskade MCP](https://github.com/taskade/docs/blob/main/apis-living-system-development/genesis-app-mcp.md).
---
## Hosted tools (48)
Every hosted tool declares MCP tool annotations. Claude can run a read-only tool without a confirmation, and it asks before a tool that deletes or replaces data.
| Area | Read-only tools | Write tools |
|---|---|---|
| Workspaces | `list_spaces`, `list_folders`, `list_media`, `list_templates`, `inspect_space`, `list_automations` | `write_file` (Genesis app source in `app/`) |
| Projects | `list_projects`, `list_my_projects`, `get_project`, `read_project`, `list_fields`, `list_blocks`, `list_project_members`, `get_share_link` | `create_project`, `create_project_from_template`, `copy_project`, `complete_project`, `restore_project`, `enable_share_link` |
| Tasks | `list_tasks` | `create_task`, `update_task`, `complete_task`, `uncomplete_task`, `delete_task`, `move_task`, `set_task_note`, `delete_task_note`, `set_task_date`, `delete_task_date`, `assign_task`, `unassign_task`, `set_task_field_value`, `delete_task_field_value` |
| AI agents | `list_agents`, `get_agent`, `list_conversations`, `get_conversation` | `create_agent`, `update_agent`, `delete_agent`, `prompt_agent`, `add_knowledge_project`, `remove_knowledge_project`, `add_knowledge_media`, `remove_knowledge_media` |
The server also serves the resource `taskade://getting-started`, a short guide for the model.
---
## Example prompts
1. **Weekly review.** "List my Taskade workspaces, read the Q4 Roadmap project, and give me the open tasks grouped by assignee."
Tools: `list_spaces`, `list_projects`, `read_project`.
2. **Plan a launch.** "Create a project called Website Launch in my Marketing workspace with tasks for copy, design, QA and launch day, and set the launch task to November 3."
Tools: `list_spaces`, `create_project`, `create_task`, `set_task_date`.
3. **Build a support agent.** "Create an agent called Help Bot in my Support workspace, add the FAQ project as its knowledge, then ask it how a customer resets a password."
Tools: `create_agent`, `add_knowledge_project`, `prompt_agent`.
4. **Close out a sprint.** "In the Sprint 42 project, mark every task that mentions 'shipped' as complete, then mark the project as completed."
Tools: `list_tasks`, `complete_task`, `complete_project`.
5. **Edit a Genesis app.** "In my CRM app, read `app/src/App.tsx` and change the page title to Acme CRM."
Tools: `inspect_space`, `write_file`.
---
## Troubleshooting
| Symptom | Cause and fix |
|---|---|
| `401 Unauthorized` on the first request | Expected. Your client must start the OAuth sign-in. If it does not, update the client or use an API token (see above). |
| `list_spaces` returns no workspaces | MCP access needs a paid plan on that workspace. Upgrade at [taskade.com/pricing](https://www.taskade.com/pricing). |
| A tool returns "permission denied" | Your role in that workspace or project does not allow the action. Ask a workspace owner for access. |
| Claude shows "Authorization with the MCP server failed" | Remove the connector, add it again, and sign in to the correct Taskade account. |
| A local `npx` server fails with "TASKADE_API_KEY appears to be invalid" | Create a new token in [Settings > API](https://www.taskade.com/settings/api). |
If the problem continues, open an [issue](https://github.com/taskade/mcp/issues) or email [support@taskade.com](mailto:support@taskade.com).
---
## Local package (stdio)
Use the local package when your client supports only stdio servers, or when you need a tool that only the local package has, for example the webhook tools (`subscribeWebhook`, `unsubscribeWebhook`). It runs on your machine with `npx` and calls the Taskade public API over the network with a personal access token.
| I want to... | Use | Where / auth |
|---|---|---|
| Use Taskade from Claude, Cursor, VS Code or another client that supports remote servers | **Hosted server** | `https://www.taskade.com/mcp` · OAuth 2.0 or API token · paid plans |
| Run Taskade tools in a client that supports only stdio, or use the webhook tools | **Local package** (`@taskade/mcp-server`) | `npx` · personal access token · needs network access to taskade.com |
| Let my Taskade agents reach Slack, Shopify or Gmail | **[MCP Connectors](https://github.com/taskade/docs/blob/main/genesis-living-system-builder/genesis/mcp-connectors.md)** | Hosted, in the Taskade app |
### 1. Get Your API Key
Go to [Taskade Settings > API](https://www.taskade.com/settings/api) and create a Personal Access Token.
### 2. Claude Desktop
Add to your `claude_desktop_config.json`:
```json
{
"mcpServers": {
"taskade": {
"command": "npx",
"args": ["-y", "@taskade/mcp-server"],
"env": {
"TASKADE_API_KEY": "your-api-key-here"
}
}
}
}
```
### 3. Cursor
Add to your Cursor MCP settings:
```json
{
"mcpServers": {
"taskade": {
"command": "npx",
"args": ["-y", "@taskade/mcp-server"],
"env": {
"TASKADE_API_KEY": "your-api-key-here"
}
}
}
}
```
### 4. Windsurf
Add to `~/.codeium/windsurf/mcp_config.json` (or **Settings → Cascade → MCP → Add Server**):
```json
{
"mcpServers": {
"taskade": {
"command": "npx",
"args": ["-y", "@taskade/mcp-server"],
"env": {
"TASKADE_API_KEY": "your-api-key-here"
}
}
}
}
```
### 5. Cline
In VS Code, open the Cline **MCP Servers** panel → **Configure MCP Servers** and add:
```json
{
"mcpServers": {
"taskade": {
"command": "npx",
"args": ["-y", "@taskade/mcp-server"],
"env": {
"TASKADE_API_KEY": "your-api-key-here"
}
}
}
}
```
### 6. VS Code
Add a `.vscode/mcp.json` to your workspace (VS Code uses the `servers` key; `${input:…}` prompts for your key on first run):
```json
{
"servers": {
"taskade": {
"command": "npx",
"args": ["-y", "@taskade/mcp-server"],
"env": {
"TASKADE_API_KEY": "${input:taskade_api_key}"
}
}
}
}
```
### 7. HTTP / SSE Mode (remote & custom clients)
```bash
TASKADE_API_KEY=your-api-key npx @taskade/mcp-server --http
```
The server starts at `http://localhost:3000` (configure with `PORT` env var). Connect via SSE at `http://localhost:3000/sse?access_token=your-api-key`.
---
## Local package tools (62)
The local package has its own tool names. They map to the Taskade public API v1 and v2.
### Workspaces
| Tool | Description |
|------|-------------|
| `workspacesGet` | List all workspaces |
| `workspaceFoldersGet` | List folders in a workspace |
| `workspaceCreateProject` | Create a project in a workspace |
### Projects
| Tool | Description |
|------|-------------|
| `projectGet` | Get project details |
| `projectCreate` | Create a new project |
| `projectCopy` | Copy a project to a folder |
| `projectComplete` | Mark project as completed |
| `projectRestore` | Restore a completed project |
| `projectMembersGet` | List project members |
| `projectFieldsGet` | Get custom fields for a project |
| `projectShareLinkGet` | Get the share link |
| `projectShareLinkEnable` | Enable the share link |
| `projectBlocksGet` | Get all blocks in a project |
| `projectTasksGet` | Get all tasks in a project |
| `folderProjectsGet` | List projects in a folder |
### Tasks
| Tool | Description |
|------|-------------|
| `taskGet` | Get task details |
| `taskCreate` | Create one or more tasks |
| `taskPut` | Update a task |
| `taskDelete` | Delete a task |
| `taskComplete` | Mark task as complete |
| `taskUncomplete` | Mark task as incomplete |
| `taskMove` | Move a task within a project |
| `taskAssigneesGet` | Get task assignees |
| `taskPutAssignees` | Assign users to a task |
| `taskDeleteAssignees` | Remove assignees |
| `taskGetDate` | Get task due date |
| `taskPutDate` | Set task due date |
| `taskDeleteDate` | Remove task due date |
| `taskNoteGet` | Get task note |
| `taskNotePut` | Update task note |
| `taskNoteDelete` | Delete task note |
| `taskFieldsValueGet` | Get all field values |
| `taskFieldValueGet` | Get a specific field value |
| `taskFieldValuePut` | Set a field value |
| `taskFieldValueDelete` | Delete a field value |
### AI Agents
Create, manage, and publish autonomous AI agents with custom knowledge and tools.
| Tool | Description |
|------|-------------|
| `folderAgentGenerate` | Generate an AI agent from a text prompt |
| `folderCreateAgent` | Create an agent with custom configuration |
| `folderAgentGet` | List agents in a folder |
| `agentGet` | Get agent details |
| `agentUpdate` | Update agent configuration |
| `deleteAgent` | Delete an agent |
| `agentPublicAccessEnable` | Publish agent publicly |
| `agentPublicGet` | Get public agent details |
| `agentPublicUpdate` | Update public agent settings |
| `agentKnowledgeProjectCreate` | Add a project as agent knowledge |
| `agentKnowledgeMediaCreate` | Add media as agent knowledge |
| `agentKnowledgeProjectRemove` | Remove project from knowledge |
| `agentKnowledgeMediaRemove` | Remove media from knowledge |
| `agentConvosGet` | List agent conversations |
| `agentConvoGet` | Get conversation details |
| `publicAgentGet` | Get agent by public ID |
### Templates
| Tool | Description |
|------|-------------|
| `folderProjectTemplatesGet` | List available project templates |
| `projectFromTemplate` | Create a project from a template |
### Media
| Tool | Description |
|------|-------------|
| `mediasGet` | List media files in a folder |
| `mediaGet` | Get media details |
| `mediaDelete` | Delete a media file |
### Personal
| Tool | Description |
|------|-------------|
| `meProjectsGet` | List all your projects |
### Agent Chat & Webhooks (API v2, beta)
Capabilities the v1 API doesn't have: hold a live conversation with an AI agent, and receive real-time events.
| Tool | Description |
|------|-------------|
| `promptAgent` | Send a message to an AI agent and get its reply |
| `listConversations` | List an agent's conversations |
| `getConversation` | Get a conversation's messages |
| `subscribeWebhook` | Subscribe to real-time Taskade event webhooks |
| `unsubscribeWebhook` | Remove a webhook subscription |
---
## Why Taskade MCP?
Taskade MCP gives your AI assistant **access to your workspace** — projects, tasks, agents, knowledge bases, templates, and automations (on paid plans; some endpoints such as workspace listing are gated for free accounts). Instead of writing API code, describe what you need in natural language.
```
┌──────────────────────────────────────────────────────────┐
│ HOW TASKADE MCP WORKS │
└──────────────────────────────────────────────────────────┘
You (in Claude/Cursor/Windsurf):
"Create a support agent trained on our docs project"
↓
┌──────────────────────────────────┐
│ Taskade MCP Server │
│ (62 tools, 8 categories) │
└──────────────────────────────────┘
↓ ↓ ↓
folderCreateAgent agentKnowledge agentPublicAccess
(creates agent) (attaches docs) (publishes it)
↓
Result: Live AI chatbot trained on your data
```
| What You Say | What Happens |
|-------------|-------------|
| "Show me all overdue tasks" | Reads projects → filters tasks → formats report |
| "Create a support agent trained on our docs" | Creates agent → attaches knowledge → publishes |
| "Set up next week's sprint from our template" | Copies template → populates tasks → assigns team |
| "Summarize yesterday's completed work" | Reads task history → generates standup summary |
### Why MCP Instead of REST API?
| | REST API | MCP Server |
|-|----------|-----------|
| **Setup** | Write HTTP client, handle auth, parse JSON | `npx @taskade/mcp-server` — one command |
| **Interface** | Code against endpoints | Natural language — describe what you need |
| **Chaining** | Manual orchestration | AI chains tools intelligently |
| **Error handling** | Write error handling code | AI interprets errors and retries |
### Why Taskade MCP Over Other MCP Servers?
Taskade is the only MCP server that includes **AI agent management** (create, train, deploy agents), **knowledge base training** (attach docs, projects, media), and **OpenAPI codegen** (generate MCP tools from any API spec). 62 tools across 8 categories.
---
## Agent Recipes
<details>
<summary><b>Recipe 1: Daily Standup Summarizer</b></summary>
<br>
**Problem:** Team standup notes scattered across Slack, email, and docs.
```
You: "Check my Taskade workspace for yesterday's completed tasks,
summarize them as a standup update, then create today's
priority tasks based on what's still open."
Claude uses:
1. meProjectsGet → find your active projects
2. projectTasksGet → pull tasks from each project
3. taskCreate → create today's priority tasks
Result: A formatted standup summary + fresh task list in Taskade.
```
</details>
<details>
<summary><b>Recipe 2: Knowledge Base Agent Builder</b></summary>
<br>
**Problem:** You have docs scattered across files and need an AI agent trained on them.
```
You: "Create an AI support agent called 'Help Bot' in my
Customer Success folder, train it on our Documentation
project, and publish it publicly."
Claude uses:
1. workspaceFoldersGet → find "Customer Success" folder
2. folderCreateAgent → create "Help Bot" with support instructions
3. agentKnowledgeProjectCreate → attach Documentation project
4. agentPublicAccessEnable → publish with shareable link
Result: Live AI chatbot trained on your docs, ready to embed.
```
</details>
<details>
<summary><b>Recipe 3: Sprint Planning Automation</b></summary>
<br>
**Problem:** Creating sprint projects manually every two weeks.
```
You: "Create a new sprint project from our 'Sprint Template',
name it 'Sprint 2026-W15', move the top 10 backlog
items into it, and assign them to the engineering team."
Claude uses:
1. folderProjectTemplatesGet → find "Sprint Template"
2. projectFromTemplate → create "Sprint 2026-W15"
3. projectTasksGet → get backlog items
4. taskMove → move top 10 tasks to new sprint
5. taskPutAssignees → assign engineering team members
Result: Sprint ready to go, fully populated and assigned.
```
</details>
<details>
<summary><This server cannot be deployed
Maintenance
ActivityNo data
ResponsivenessSyncing