Taskade Developer API

TL;DR: Taskade gives developers programmatic control of a workspace through a REST API v1 (full task CRUD), an Action API v2 (adds promptAgent), OAuth 2.0 and personal token auth, and hosted MCP connectors. Turn any published AI agent into a callable endpoint, and wire events to your own app with an automation plus an HTTP Request action.

Taskade provides a powerful REST API and Model Context Protocol (MCP) interface for developers to build custom integrations, automate workflows, and extend their workspace capabilities programmatically.

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; tasks are read-only.

Key capabilities:

• Projects — Create, read, update, and delete projects and their contents
• 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 MCP connectors 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 read-only in v2 (listTasks, listBlocks) — for full task CRUD use v1
• Browse the live spec at /api/documentation/v2

Authentication

Authenticate API requests using your Personal API Token or 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 authenticate via Taskade's OIDC provider before accessing 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. This is one of Taskade's most powerful developer features — 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 Connectors (Model Context Protocol)

MCP v2 (Hosted) is Taskade's implementation of the Model Context Protocol — a universal standard for connecting AI agents to external tools and data sources.

What is MCP?

The Model Context Protocol (MCP) is an open protocol that provides a standardized way for AI models to interact with external tools, APIs, and data sources. Taskade's hosted MCP connectors let you:

• Connect to any MCP-compatible service with zero setup — fully managed by Taskade
• Use stateless MCP servers for lightweight, scalable integrations (v6.117.0+)
• Browse 100+ connectors in the Integrations Directory
• Build custom MCP servers to expose your own APIs as AI tools

MCP vs Native Integrations

Taskade supports two integration approaches:

Building Custom MCP Servers

Developers can build their own MCP servers to expose custom APIs as tools for Taskade agents and automations:

1. Implement the MCP protocol — Follow the MCP specification to expose your tools
2. Host your server — Deploy to any infrastructure (cloud, on-premises, edge)
3. Connect to Taskade — Add your MCP server URL in Taskade's Integrations settings
4. Use in agents & automations — Your tools become available as agent capabilities and automation actions

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

For the latest API documentation, changelog, and SDKs, visit developers.taskade.com.

Start Building

Ready to build? Create your first Taskade Genesis app and use the API to extend it with custom integrations.

Explore the Community

🌎

Browse apps, agent templates, and automation flows built by the Taskade community at taskade.com/community.

---

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 with full task CRUD, so it is the one to use for creating, updating, and deleting tasks. 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, but tasks are read-only, so reach for v1 when you need to change task data.

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, automations, and MCP connectors covered here. This pairs natural-language app building with full developer control, so you can wire in custom integrations and proprietary systems. 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 agents
• 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, Cursor to Taskade