Taskade Developer API

Overview

Taskade gives developers programmatic control of a workspace. Use the REST API to build custom integrations and automate workflows, and 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 sign-in and personal token auth, and a hosted MCP server that external AI clients like Claude and Cursor can connect into. Turn any published AI agent into a callable endpoint, and wire events to your own app with an automation plus an HTTP Request action.

The Three Pillars of Workspace DNA. The Developer API connects to all three pillars: Memory (Projects & Databases), Intelligence (AI Agents), and 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 (e.g. 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

Authentication

Authenticate API requests with your Personal API Token, or let people sign in with their Taskade account (OAuth 2.0) when your app acts on their behalf.

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, authorize once over OAuth 2.0 with PKCE, and that client can work with your projects, tasks, agents, automations, and Taskade Genesis app files. It is included on every paid plan. Full setup: Taskade MCP Server.

• Read and act on your workspace. List spaces, inspect a space, list tasks, write files, and more
• One hosted endpoint with OAuth sign-in. Authorize from your client in the browser, with nothing to deploy or maintain
• Browse 100+ connectors in the Integrations Directory for native, non-MCP integrations

The opposite direction runs through automations. The MCP Client connector calls tools on any remote MCP server as a step, on every plan, though an agent cannot reach a server on its own. To reach your other systems from inside Taskade, let automations carry the work into the 100+ apps you already use, expose a service to an agent with the 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:

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. Sign in when prompted: the hosted server authorizes with OAuth through your browser using your Taskade account, so there is no API key to paste. See the MCP Server guide 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

If you need full local control or a custom HTTP/SSE endpoint, 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
2. Run the server: npx -y @taskade/mcp-server, or add --http for an SSE endpoint
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

Tasks

Agents

Webhooks

Taskade does not have a webhook-subscription endpoint (there is no POST /api/v2/webhooks to register URLs against). Instead, you deliver events to your own app by building an automation: pick a Taskade trigger and 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.

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 doesn't change frequently
• Secure your tokens: Never expose API tokens in client-side code. Use server-side requests

💡 Note: Visit the Developer Docs for the complete, always-current API reference. It covers every REST v1 endpoint, every Action API v2 operation, plus guides and MCP setup.

Start Building

💡 Tip: Ready to build? Create your first Taskade Genesis app, then use the API to extend it with custom integrations. The 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.

---

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, 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 and uses an action-style design where every call is a POST to a named operation. v2 adds promptAgent, and since August 2026 it also writes tasks in an existing project. Reach for v1 when you need to read a single task by ID, which v2 does not offer. 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, and you should add exponential backoff when you receive a 429 response. 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 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, and 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 to get started.

---

Related guides

• Public API. REST endpoints for workspace data.
• MCP Server. Model Context Protocol endpoint for external AI clients.
• Webhooks. Inbound events from external systems.
• HTTP Request Action. Outbound API calls from automations.
• Agent Tool Trigger. Expose automations as agent tools.
• MCP Connectors. Connect Claude Desktop and Cursor to Taskade.
• Developer Docs. Endpoint-by-endpoint reference for REST v1 and Action API v2, with guides for webhooks, bundles, and the SDK.