# Taskade Developer API

> Taskade provides a powerful REST API for custom integrations and automations, plus a hosted Model Context Protocol (MCP) server that AI clients like Claude and Cursor can connect to.

- Source: https://www.taskade.com/learn/connect/developer-api
- Section: Connect
- Updated: 2026-10-20
- Index of all pages: https://www.taskade.com/learn/llms.txt

## Overview

Taskade gives developers programmatic control of a workspace. Use the REST API to build custom integrations and automate workflows. Connect AI clients like Claude and Cursor into your workspace through the hosted Model Context Protocol (MCP) server.

> **TL;DR:** Taskade gives developers programmatic control of a workspace through a REST API v1 (full task CRUD), an Action API v2 (adds promptAgent), account or token auth, and a hosted MCP server for Claude and Cursor. Turn a published agent into a callable endpoint, or wire events to your app with an [automation](https://www.taskade.com/learn/automation/automations-execution) plus HTTP Request.

> 💡
>
>
>
> **The Three Pillars of Workspace DNA.** The Developer API connects to all three pillars: [Memory](https://www.taskade.com/learn/projects/databases) (Projects & Databases), [Intelligence](https://www.taskade.com/learn/agents/custom-agents) (AI Agents), and [Execution](https://www.taskade.com/learn/automation/automations-execution) (Automations).

## REST API Overview

Taskade ships **two** public APIs: a complete **REST API v1** and a newer **Action API v2**. Both return JSON and use the same authentication.

**Base URLs:**
- **REST API v1**: `https://www.taskade.com/api/v1`. RESTful (`GET`/`POST`/`PUT`/`DELETE`), GA, full task CRUD.
- **Action API v2**: `https://www.taskade.com/api/v2`. Action/RPC (`POST /{operation}`), beta. Adds `promptAgent`, plus task writes in an existing project since August 2026.

Key capabilities:

- **Projects**: Create, read, complete, restore, and copy projects, and manage their share links (renaming and deleting a project stay in the app)
- **Tasks**: Manage tasks, subtasks, due dates, assignments, and custom fields
- **Agents**: Prompt AI agents programmatically and receive structured responses
- **Workspaces**: Manage workspace settings, members, and permissions
- **Media**: Access and manage media files in your workspace

### API v2 (Public API v2)

> ℹ️
>
>
>
> **Vibe Coding + Developer API.** Build apps with vibe coding, then extend them programmatically with the Taskade API. Combine natural language app building with REST endpoints, webhooks, and the hosted MCP server for maximum flexibility.

Taskade's **Action API v2** (beta) is an action/RPC API: every call is a `POST` to a named operation (for example, `POST /api/v2/listSpaces`, `POST /api/v2/promptAgent`, `POST /api/v2/createProject`). It is **not** RESTful, so there are no `GET /api/v2/...` resource paths. Notes:

- Success responses are wrapped as `{ ok: true, ... }`. Errors are `{ ok: false, message, code, statusMessage }`
- Cursor-based pagination (`after` / `before`) on list operations
- **Tasks are writable in v2** since August 2026: `createTask`, `updateTask`, `completeTask`, `moveTask`, `deleteTask`, and the note, date, assignee, and custom field operations. Project-level updates still live in v1
- Browse the live spec at [/api/documentation/v2](https://www.taskade.com/api/documentation/v2)

## Authentication

Authenticate API requests with your **Personal API Token**. When your app acts for other people, let them **sign in with their Taskade account** (OAuth 2.0).

### Personal API Token

Generate a personal API token from your **Settings → API** page. Include it in the `Authorization` header:

`Authorization: Bearer YOUR_API_TOKEN`

### OAuth 2.0

For apps that need to access Taskade on behalf of other users, use OAuth 2.0 authorization flow:

1. Register your application in Taskade's developer settings
2. Redirect users to the authorization endpoint
3. Exchange the authorization code for an access token
4. Use the access token in API requests

### OIDC (OpenID Connect)

Taskade Genesis apps support **OIDC authentication** for secure, standardized sign-in. This enables:

- **Secure app access**: Users sign in through Taskade before opening your published Taskade Genesis app
- **User identity verification**: Get verified user identity claims (email, name, profile)
- **Standards-compliant**: Full OAuth 2.0 / OpenID Connect protocol support

## Agent Public API

The **Agent Public API** (v6.110.0+) lets you prompt any published AI agent programmatically via REST. It turns every AI agent into a callable API endpoint.

### Inside the Agent Public API

1. **Publish an agent**: Set your agent to "Public" in the agent settings
2. **Get the agent ID**: Copy the agent's unique identifier from the share dialog
3. **Send prompts via API**: POST your prompt to the agent endpoint
4. **Receive structured responses**: Get the agent's response as JSON

### Use Cases

- **Chatbots**: Power custom chatbots with your trained Taskade agents
- **Automated workflows**: Trigger agent responses from external systems
- **Data processing**: Send documents for analysis and receive structured output
- **Multi-agent pipelines**: Chain multiple agent calls for complex workflows
- **SaaS integrations**: Embed Taskade AI capabilities into your own applications

> 💡
>
>
>
> The Agent Public API respects your agent's training, knowledge sources, and tool permissions. Your agent will respond with the same intelligence and capabilities it has in Taskade's UI.

## MCP (Model Context Protocol)

The **Model Context Protocol (MCP)** is the open standard AI clients use to discover and call tools and data. Taskade implements the **server** side of that standard: your workspace is published as a hosted MCP server that external AI clients connect into.

### The hosted Taskade MCP server

Point Claude Desktop, Cursor, Windsurf, VS Code, n8n, or any MCP client at `https://www.taskade.com/mcp`, then connect it one of two ways. Sign in through your browser with OAuth 2.0, or paste a Personal Access Token from [Settings → API](https://www.taskade.com/settings/api). That client can then read your projects, tasks, agents, automations, and Taskade Genesis app files, and create or update projects, tasks, and agents. It can also start a run of an automation that starts with the Agent Tool trigger, and read its recent runs. It is included on **every paid plan**. Full setup: [Taskade MCP Server](https://www.taskade.com/learn/connect/mcp-server).

- **Read and act on your workspace**. Browse spaces and folders, create and update tasks, build and question agents, and edit your app files
- **One hosted endpoint, two ways to connect**. Authorize in the browser, or paste a Personal Access Token, with nothing to deploy or maintain
- **Browse 100+ connectors** in the [Integrations Directory](https://www.taskade.com/integrations) for native, non-MCP integrations

The opposite direction runs through automations. The [MCP Client connector](https://www.taskade.com/learn/connect/mcp-client-integration) calls tools on any remote MCP server as a step, on every plan. An agent cannot reach a server on its own. To reach your other systems from inside Taskade, you have three options. Let [automations](https://www.taskade.com/learn/automation/automations-execution) carry the work into the 100+ apps you already use. Expose a service to an agent with the [HTTP Request](https://www.taskade.com/learn/automation/http-request) action. Or call that service from your own code with the REST API.

### MCP server vs REST API

Both give you programmatic reach into a workspace. They differ in who does the calling:

| Feature | REST API | Hosted MCP server |
| --- | --- | --- |
| Caller | Your own code | An external AI client (Claude Desktop, Cursor, VS Code) |
| Auth | Personal Access Token or OAuth | Browser sign-in with OAuth 2.0, or the same Personal Access Token |
| Shape | Endpoints you call explicitly | Workspace tools the client discovers and calls |
| Best for | Custom integrations, scripts, backends | Working on your Taskade workspace from an AI editor |

### Connecting an MCP client

Point any MCP-compatible client at Taskade's hosted server to work with your workspace from outside the app:

1. **Check your plan**: the hosted MCP server is available on every paid plan
2. **Add Taskade to your client**: configure Claude Desktop, Cursor, or your own MCP client with Taskade's hosted MCP endpoint
3. **Pick how you sign in**: approve the browser window the hosted server opens, or paste a Personal Access Token from [Settings → API](https://www.taskade.com/settings/api) when your client cannot open a browser. See the [MCP Server guide](https://www.taskade.com/learn/connect/mcp-server) for client-specific setup
4. **Use the workspace tools**: tools like `list_spaces`, `inspect_space`, `list_tasks`, and `write_file` become available inside the client

### Self-host the MCP server

For full local control, run the open-source `@taskade/mcp-server` package with a Personal Access Token instead of the hosted server. It works on any plan, including Free:

1. **Generate a token**: create a Personal Access Token at [Settings → API](https://www.taskade.com/settings/api)
2. **Run the server**: `npx -y @taskade/mcp-server`. Your AI tool starts it on your computer. To serve it at a web address instead, follow the [HTTP mode steps in Workspace MCP](https://www.taskade.com/docs/mcp/workspace-mcp#http-sse-mode)
3. **Point your client at it**: add the command to your client's MCP config
4. **Use it**: the same workspace, exposed to a client you run yourself

## Core API Endpoints

### Projects

| Method | Endpoint | Description |
| --- | --- | --- |
| GET | /projects | List all projects in a workspace |
| POST | /projects | Create a new project |
| GET | /projects/:id | Get project details |
| PUT | /projects/:id | Update a project |
| DELETE | /projects/:id | Delete a project |

### Tasks

| Method | Endpoint | Description |
| --- | --- | --- |
| GET | /projects/:id/tasks | List tasks in a project |
| POST | /projects/:id/tasks | Create a task |
| PUT | /tasks/:id | Update a task (title, due date, assignees, custom fields) |
| DELETE | /tasks/:id | Delete a task |
| POST | /tasks/:id/complete | Mark a task as completed |

### Agents

| Method | Endpoint | Description |
| --- | --- | --- |
| POST | /agents/:id/prompt | Send a prompt to an agent |
| GET | /agents/:id | Get agent metadata and capabilities |
| GET | /agents/:id/conversations | List agent conversations |

## Webhooks

Taskade does **not** have a webhook-subscription endpoint (there is no `POST /api/v2/webhooks` to register URLs against). Instead, deliver events to your own app with an **automation**. Pick a Taskade **trigger**, then add an **HTTP Request** action that POSTs to your endpoint.

Common triggers:

- **Task added** (`task.added`) / **Task completed** (`task.completed`)
- **Project completed**, **New comment**, **Due date reached**
- **Form submission received**

To receive data **into** Taskade from an external system, use the inbound **Webhook trigger** in an automation flow (optionally Bearer-authenticated). See the [Automation Engine](https://www.taskade.com/learn/automation/automations-execution).

## Rate Limits & Best Practices

- **Respect rate limits**: API responses include rate limit headers. Implement exponential backoff on 429 responses
- **Use pagination**: For large result sets, use cursor-based pagination instead of fetching everything at once
- **Cache when possible**: Cache responses for data that does not change frequently
- **Secure your tokens**: Never expose API tokens in client-side code. Use server-side requests

> **💡 Note**: Visit the [Developer Docs](https://www.taskade.com/docs) for the complete, always-current API reference. It covers every [REST v1 endpoint](https://www.taskade.com/docs/rest), every [Action API v2 operation](https://www.taskade.com/docs/actions), plus [guides](https://www.taskade.com/docs/guides) and [MCP setup](https://www.taskade.com/docs/mcp).

### Start Building

> **💡 Tip**: Ready to build? [Create your first Taskade Genesis app](https://www.taskade.com/create), then use the API to extend it with custom integrations. The [Action API guide](https://www.taskade.com/docs/getting-started/action-api-guide) walks through your first call in five minutes.

### Explore the Community

> 🌎
>
>
>
> Browse apps, agent templates, and automation flows built by the Taskade community at [taskade.com/apps](https://www.taskade.com/apps).

---

## Frequently Asked Questions

**What is the difference between API v1 and API v2?**

REST API v1 is the generally available, fully RESTful API at `https://www.taskade.com/api/v1`. It supports `GET`, `POST`, `PUT`, `PATCH`, and `DELETE`, and it covers full task CRUD plus project create, complete, restore, copy, and share-link operations. Action API v2 (beta) lives at `https://www.taskade.com/api/v2`. It uses an action-style design, where every call is a `POST` to a named operation. v2 adds `promptAgent`. Since August 2026, it also writes tasks in an existing project. When you need to read a single task by ID, use v1. v2 does not offer that call. Neither version can rename or delete a project, so make those changes in the app.

**How do I authenticate my API requests?**

You authenticate with a Personal API Token or with OAuth 2.0. For a token, add it to the request as a header in the form `Authorization: Bearer YOUR_API_TOKEN`. Use OAuth 2.0 when your app needs to act on behalf of other users, since it issues an access token through an authorization flow.

**Where do I get a Personal API Token?**

Open your **Settings → API** page and generate a Personal API Token there. Include that token in the `Authorization` header on every request. Keep it on the server side and never paste it into client-side code, since anyone with the token can act as you.

**Can I turn an AI agent into an API endpoint?**

Yes. The Agent Public API lets you prompt any published agent over REST, so each agent becomes a callable endpoint. Set the agent to "Public", copy its agent ID from the share dialog, then POST your prompt and receive a structured JSON response. The agent answers with the same training, knowledge sources, and tool permissions it has inside Taskade.

**Are there rate limits on the API?**

Yes. API responses include rate limit headers. When you receive a 429 response, add exponential backoff. For large result sets, use cursor-based pagination instead of fetching everything at once, and cache data that does not change often. These habits keep your integration fast and well within limits.

**How do I send events from Taskade to my own app?**

Build an automation. Pick a Taskade trigger like **Task added** or **Task completed**, then add an **HTTP Request** action that POSTs the event to your endpoint. To pull data the other way, use the inbound **Webhook trigger** in an automation flow, which you can protect with a Bearer token. See the [Automation Engine](https://www.taskade.com/learn/automation/automations-execution) for the full setup.

**Can I extend a Taskade Genesis app with the API?**

Yes. Build your app with vibe coding, then extend it programmatically with the REST endpoints, agent prompts, and automations covered here. Call your own systems and proprietary services from an automation's HTTP Request action. Work on the same workspace from Claude or Cursor through the hosted MCP server. That pairs natural-language app building with full developer control. [Create your first Taskade Genesis app](https://www.taskade.com/create) to get started.

---

### Related guides

- [Public API](https://www.taskade.com/learn/connect/public-api). REST endpoints for workspace data.
- [MCP Server](https://www.taskade.com/learn/connect/mcp-server). Model Context Protocol endpoint for external AI clients.
- [Webhooks](https://www.taskade.com/learn/automation/webhooks). Inbound events from external systems.
- [HTTP Request Action](https://www.taskade.com/learn/automation/http-request). Outbound API calls from automations.
- [Agent Tool Trigger](https://www.taskade.com/learn/automation/agent-tool). Expose automations as agent tools.
- [MCP Connectors](https://www.taskade.com/learn/genesis/mcp-connectors). Connect Claude Desktop and Cursor to Taskade.
- [Developer Docs](https://www.taskade.com/docs). Endpoint-by-endpoint reference for [REST v1](https://www.taskade.com/docs/rest) and [Action API v2](https://www.taskade.com/docs/actions), with [guides](https://www.taskade.com/docs/guides) for webhooks, bundles, and the SDK.
