Connect Todoist to ChatGPT: Sync Projects, Tasks, and Comments

If you need to connect Todoist to ChatGPT to automate task creation, manage project boards, or sync comments from other platforms, you need a Model Context Protocol (MCP) server. This server acts as the critical translation layer between ChatGPT's JSON-RPC tool calls and the Todoist REST API. You can either build, host, and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds. If your team uses Claude, check out our guide on connecting Todoist to Claude or explore our broader architectural overview on connecting Todoist to AI Agents.

Giving a Large Language Model (LLM) read and write access to your productivity system is an engineering challenge. You have to handle OAuth 2.0 authorization flows, map massive JSON schemas to MCP tool definitions, manage pagination cursors, and deal with vendor-specific rate limits. Every time Todoist updates an endpoint, you have to update your server code. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Todoist, connect it natively to ChatGPT, and execute complex project workflows using natural language.

The Engineering Reality of the Todoist API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against vendor APIs is painful. If you decide to build a custom MCP server for Todoist, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Todoist:

The Sync API vs. REST API Paradigm Todoist maintains two distinct APIs: a Sync API and a REST API. The Sync API is designed for client applications that need to maintain offline state, heavily relying on sync_token tracking to fetch delta updates. Exposing this directly to an LLM is a disaster - LLMs are stateless and terrible at managing long-lived synchronization tokens. Your MCP server must exclusively wrap the stateless REST v2 API, or build heavy abstraction layers to translate stateless tool calls into stateful sync operations.

UUID Generation for Idempotency When creating tasks or projects in Todoist, the API strongly recommends (and sometimes requires) passing a client-generated UUID as an X-Request-Id header to ensure idempotency. If a network timeout occurs, you can safely retry the request without creating duplicate tasks. LLMs cannot generate deterministic UUIDs reliably. If your custom server relies on the LLM to provide the request ID, you will end up with duplicate tasks every time the model hallucinates or retries a call.

Strict Rate Limiting and 429 Errors Todoist enforces strict rate limits based on the user's plan. When integrating this with agentic workflows, LLMs can easily exceed these limits if they attempt to list tasks across dozens of projects in a loop. Note on how Truto handles this: Truto does not retry, throttle, or apply automatic backoff on rate limit errors. When the Todoist API returns an HTTP 429, Truto passes that error directly to the caller. However, Truto automatically normalizes the vendor-specific rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The LLM or agent framework calling the tool is responsible for reading these headers and executing its own exponential backoff.

Generating the Managed MCP Server for Todoist

Instead of manually coding tool schemas and managing token lifecycles, Truto dynamically derives MCP tools directly from the integration's documented API resources. A tool only appears in the MCP server if it has a verified documentation entry, ensuring the LLM only receives highly curated, reliable endpoints.

Every MCP server in Truto is scoped to a single integrated account and protected by a cryptographically hashed token in the URL. You can generate this server using two different methods.

Method 1: Generating the Server via the Truto UI

For ad-hoc configurations and testing, the UI provides a fast path to generation:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Todoist account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., name, allowed methods like read or write, and expiration time).
5. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Generating the Server via the API

For programmatic, multi-tenant agent deployments, you can provision servers on the fly using the Truto REST API. This validates that the Todoist integration is AI-ready, generates a secure token stored in a distributed key-value store, and returns the endpoint.

Endpoint: POST /integrated-account/:id/mcp

// Example Request
const response = await fetch('https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${TRUTO_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "ChatGPT Todoist Integration",
    config: {
      methods: ["read", "write"],
      tags: ["projects", "tasks", "comments"]
    },
    // Optional: Auto-expire the server next week
    expires_at: "2026-10-15T00:00:00Z"
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); 
// Output: https://api.truto.one/mcp/abcdef123456...

Connecting the Todoist MCP Server to ChatGPT

Once you have the secure URL, connecting it to ChatGPT takes less than a minute. You do not need to configure OAuth or pass additional environment variables - the Truto MCP URL handles authentication routing automatically.

Method A: Via the ChatGPT UI

If you are using ChatGPT Enterprise, Pro, or Plus with Developer Mode enabled:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the MCP servers / Custom connectors section, click Add new server.
4. Name: "Todoist via Truto"
5. Server URL: Paste the Truto MCP URL you generated in the previous step.
6. Click Save. ChatGPT will instantly ping the endpoint, execute the tools/list JSON-RPC handshake, and load the Todoist capabilities into your workspace.

Method B: Via Manual Config File

If you are running a custom desktop agent, Cursor, or a local LangChain framework that expects an MCP config file, you can connect to the Truto endpoint using the standard Remote SSE Transport.

Create or update your mcp.json (or mcp_config.json) file:

{
  "mcpServers": {
    "todoist-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN"
      ]
    }
  }
}

Hero Tools for Todoist Workflows

Truto automatically transforms Todoist's REST endpoints into descriptive, snake_case tools complete with injected JSON schemas. We inject properties like limit and next_cursor automatically to guide the LLM on pagination behavior.

Here are 6 high-leverage hero tools exposed by the Todoist MCP server.

list_all_todoist_projects

This tool retrieves all active projects in the workspace. It is essential for mapping project names to internal id values, which are required for subsequent task creation calls. It returns fields including the project ID, comment count, order, view style, and whether the project is shared.

"Fetch all my Todoist projects and give me the internal ID for the 'Q4 Product Launch' project."

list_all_todoist_tasks

Retrieves all active tasks across all projects, or scoped to a specific project if the LLM passes a project_id in the query schema. It returns deep metadata including due objects (date, string, timezone), deadlines, labels, and assignment details.

"List all active tasks in the 'Marketing Website' project that have a priority of 4."

create_a_todoist_task

Creates a new task. The LLM only strictly needs to provide the content property, but it can seamlessly utilize natural language dates (which Todoist parses) or explicit due objects. It can also assign the task to specific projects or sections.

"Create a new high-priority task in the 'Engineering' project called 'Review database migration PR' due tomorrow at 10 AM."

update_a_todoist_task_by_id

Modifies an existing task. The LLM must pass the task id alongside any fields it wishes to mutate, such as updating the description, changing priority, or extending the deadline.

"Update task ID 123456789. Change its description to 'Awaiting final QA sign-off' and set the label to 'blocked'."

todoist_tasks_close

Closes an active task, moving it to the history log. For recurring tasks, this tool correctly handles the Todoist logic of scheduling the next occurrence rather than archiving the task entirely.

"I just finished the 'Draft Q3 OKRs' task. Please mark it as complete in Todoist."

create_a_todoist_comment

Appends a new comment to a specific task or project. This is highly useful for AI agents that act as researchers, attaching their findings directly to the relevant Todoist ticket.

"Add a comment to task ID 987654321 with the summary of our sync meeting notes."

For the complete inventory of available Todoist tools, including section management, personal labels, and shared collaborators, view the Todoist integration page.

Workflows in Action

Connecting an LLM to Todoist unlocks agentic capabilities that go far beyond simple voice commands. Because the MCP server provides exact schemas and real-time read/write capabilities, ChatGPT can orchestrate complex triage and planning workflows.

Scenario 1: Daily Triage and Rescheduling

Knowledge workers often end the day with overdue tasks scattered across multiple projects. You can ask ChatGPT to act as your executive assistant to triage your workload.

"Find all my overdue tasks across all projects. Move any low-priority tasks to next Friday, and generate a summarized list of the high-priority ones I missed so I can tackle them tomorrow morning."

Step-by-step execution:

1. Read data: ChatGPT calls list_all_todoist_tasks with a date filter parameter to retrieve overdue items.
2. Analyze & Decide: The model evaluates the priority field of the returned task objects.
3. Write data (Loop): For every task with a low priority (e.g., priority 1 or 2), ChatGPT calls update_a_todoist_task_by_id and sets the due_string to "next Friday".
4. Final output: The model renders a clean markdown summary of the remaining high-priority tasks directly in the chat interface.

Scenario 2: Project Breakdown and Delegation

When starting a large initiative, breaking it down into actionable tickets is tedious. You can feed a project spec to ChatGPT and have it build out the Todoist structure automatically.

"I am launching a new email newsletter. Create a new Todoist project called 'Newsletter Launch'. Then, break down the process into 5 tasks, assign them to that new project, and give them staggered due dates over the next week."

Step-by-step execution:

1. Create Project: ChatGPT calls create_a_todoist_project with the name "Newsletter Launch" and captures the returned id.
2. Generate Tasks: The LLM internally reasons about what it takes to launch a newsletter (design template, write first issue, set up DNS records, configure ESP, launch).
3. Batch Write: The model calls create_a_todoist_task five separate times, injecting the captured project id and calculating staggered due_string values (e.g., "in 1 day", "in 3 days").
4. Final output: The LLM confirms the project setup is complete and links to the new project board.

Security and Access Control

Exposing your task management system to an autonomous agent requires strict boundaries. Truto MCP servers implement granular security controls at the infrastructure level, preventing the LLM from executing unauthorized operations.

• Method Filtering: When creating the server, you can restrict access entirely to read operations. An MCP server configured with methods: ["read"] will only generate tools for GET and LIST endpoints, physically preventing the LLM from modifying or deleting tasks.
• Tag Filtering: You can restrict the AI to specific API namespaces. By applying tags: ["comments"], the server will strip away tools for managing projects or collaborators, confining the agent to comment threads.
• Require API Token Auth: By default, possession of the MCP URL grants access. For enterprise deployments, setting require_api_token_auth: true forces the client to pass a secondary Truto API token in the Authorization header, adding defense-in-depth.
• Time-To-Live (TTL): You can set an expires_at timestamp. Truto stores this in a distributed key-value store and schedules a time-to-live trigger. Once the timestamp hits, the token is automatically wiped, instantly revoking the LLM's access to Todoist.

Moving Past Manual Integrations

Building a custom integration layer for Todoist requires engineering resources to handle sync tokens, UUID idempotency, and strict pagination. By using an auto-generated MCP server, you abstract away the API maintenance completely. Your LLM gets instant, typed, and schema-validated access to the entire Todoist ecosystem.