# Todoist API: Endpoints, Rate Limits and Errors (2026)

By Amit Patel · 2026-11-22 · Source: https://www.activepieces.com/blog/todoist-api-endpoints-rate-limits-and-errors-2026

---
<aside class="tldr"><p class="tldr-label">Summary</p><p>Production Todoist API integrations must handle rate limits (1,000 per 15 minutes), project caps (Pro 300, Business 500), and seven predictable errors.</p><ul><li>1,000 REST calls per 15 minutes; full syncs: 100 per 15 minutes.</li><li>Pro plan allows 300 projects; Business plan allows 500 projects.</li><li>Duplicate tasks result from retried creates after timeouts without tracking.</li></ul></aside>

A first task needs only a token and one request.

The ([source](https://www.todoist.com/pricing)) API is Todoist's own HTTP interface for reading and writing tasks, projects and other account data, and it is the same layer that tools like [Activepieces](https://www.activepieces.com) talk to when they connect to an account.

That part is easy, so it proves little. The integrations that survive production are the ones designed around rate limits, ID handling and API version changes from the start.

For scripts, cron jobs and prototypes, the personal token Todoist issues for your own account is enough. **Treat it like a password**. It carries your full access, so keep it in an environment variable, never in a repository, and regenerate it if it leaks.

![A personal token written on a card, kept in an environment variable file on a laptop screen's side, with a locked drawer…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/15eea908-95a6-40ee-853e-97491d8bec95/todoist-api-endpoints-rate-limits-and-errors-202-72f15aad.webp)

## Your first Todoist API request

### Todoist OAuth for multi-user apps

If your app acts on behalf of other people, each user must authorize it through OAuth, and your app stores a token per user. A personal token only works for you.

Start with the personal token to learn the API, then move to OAuth before anyone else's data touches your code.

### A minimal curl request that creates a task

Nothing here needs more than a terminal and a browser tab. The steps below are the whole first run, from settings page to a task in your account.

1. Open Todoist, then go to Settings > Integrations > Developer.
2. Copy the personal API token shown there and export it as `TODOIST_TOKEN`.
3. Send a POST to the tasks endpoint with a Bearer header and JSON content:

![A Todoist Settings page open on Developer integrations with a personal API token field, beside a terminal showing a POST to…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/a343f8d7-1f53-461f-b120-503310e6259f/todoist-api-endpoints-rate-limits-and-errors-202-30d4b102.webp)

 ```bash
 curl -X POST https://api.todoist.com/api/v1/tasks \
 -H "Authorization: Bearer $TODOIST_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{"content": "Buy oat milk"}'
 ```

Then open the Inbox in Todoist and confirm the task is there.

When you get a 401 response, the token is wrong or missing from the header. A task that never appears usually means the request failed and you didn't read the response.

![Activepieces workflow builder with HTTP request step selected and its settings panel open showing method, URL, headers, and…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/9e36e973-de4a-435f-8912-12e666216b2d/self-host-mistral-ai-enterprise-deployment-guide-3f7fe28d.webp)

Check the status code every time, even in a throwaway script, because the habit carries into production. The response also returns the new task's ID, and the next sections explain why you should store it carefully.

## Todoist API Endpoints, Pricing and Rate Limits

That task ID belongs to one of six resource groups.

**None is billed per request**, and the ceiling is **1,000 REST calls per 15 minutes**; exceeding this limit triggers throttling.

Everything except the webhook setup lives under one API v1 base path, so one client wrapper can cover all of it. The table shows what each group does and the call you'll hit first.

![Todoist API request limits by call type](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/767847a0-744c-455a-8196-c7471a81bdad/todoist-api-endpoints-rate-limits-and-errors-202-d98be29f.svg "Source: Datrise")

| Resource | What it does | Key call | In API v1 |
|---|---|---|---|
| Tasks | Create, update, close, move work items | `POST /tasks` | Yes |
| Projects | Group tasks; hold sharing and hierarchy | `POST /projects` | Yes |
| Sections | Split a project into columns or stages | `POST /sections` | Yes |
| Labels | Tag tasks across projects | `POST /labels` | Yes |
| Comments | Attach notes to tasks or projects | `POST /comments` | Yes |
| Sync/webhooks | Batch commands, incremental reads, change notifications | `POST /sync` | Yes |
| *Docs checked 22 November 2026* | | | |

Tasks carry most traffic. Sync and webhooks matter most once polling becomes your bottleneck.

### Pricing: what the API costs per request

Nothing: ([source](https://www.todoist.com/pricing)) lists plan prices and no per-request fee, so you pay for seats, not calls.

Pro is $7 per user per month billed monthly and $5 billed yearly, so annual billing saves $2 per seat. Business is $10 monthly and $8 yearly, the same $2 saving, so choosing yearly billing realizes this monthly discount.

![Two price cards side by side for Pro and Business, each showing a monthly price tag and a lower yearly price tag, with a…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/ff328f9f-d4cb-415d-9083-60c4b95cfae8/todoist-api-endpoints-rate-limits-and-errors-202-ddf6b0e6.webp)

Create one project per client and Beginner stalls almost immediately, because it allows 5 projects. That is where project caps bite. **Pro allows 300 and Business 500**, so a per-client design works at those sizes but still has a hard stop.

![Todoist project limits on each plan](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/d1311785-a44e-41ef-8370-b0d35f0d0595/todoist-api-endpoints-rate-limits-and-errors-202-a7612105.svg "Source: Todoist")

### Rate limits by call type

Per [Datrise's integration notes](https://datrise.com/en/integrations/source/todoist), REST calls and partial syncs each get 1,000 requests per 15 minutes, while full syncs get only 100.

That's one full sync every 9 seconds, so a loop that re-downloads all state on a timer will exhaust its budget in 15 minutes and start failing.

On burst behavior, Todoist hasn't published a figure that I could confirm. Treat 429 responses as normal: **back off with jitter, and never retry a create blindly, or you may make duplicate tasks.**

### Which API version to build on

Build on API v1, the version the table reflects. Pin the version in one config value so a future change is a one-line edit, not a hunt through call sites.

## The Case for Skipping the Todoist API Entirely

Pinning a version caps the cost of change. The cheapest integration to maintain is the one you never write, and for many needs Todoist's built-in routes do the job without any code.

Glue code is debt: every retry loop, ID map and version bump is yours to carry, and it fails at 2 a.m. rather than in review.

### When built-in integrations are enough

If the need is "get something into Todoist" or "see Todoist things elsewhere," start by checking these four, none of which needs a token, a deploy or an on-call rotation:

<blockquote class="pull"><p>Glue code is debt: every retry loop, ID map and version bump is yours to carry, and it fails at 2 a.m. rather than in review.</p></blockquote>

- Email-in, for turning forwarded messages into tasks, which covers capture from inboxes and tools that can only send mail
- The directory of built-in integrations (80+), which means the tool you want to connect has a fair chance of already being covered by a maintained connector
- A calendar feed, for tasks with dates that need to appear alongside meetings in a calendar app
- Todoist's own AI features, which are worth reading about on its pages for what they currently claim to do, rather than assuming from this article

Those routes share one property: Todoist owns the failure modes. When a connector breaks after a platform change, someone else's team fixes it, and you aren't the one reading error logs.

That's a real argument, and for a personal workflow or a small team's intake it usually wins.

### When the API is still the right call

The built-ins stop where your logic starts. Email-in creates a task but can't decide which project it belongs in based on your data.

A calendar feed is one-directional, so nothing you do there flows back. A directory connector does what its author imagined, and when your case differs, you can't patch it.

Reach for the API when you need two-way sync, conditional routing, bulk changes, or tasks created from your own system's events. Those are the cases where silent mismatches cost you.

You want control over retries, rate-limit backoff and ID mapping rather than trusting a black box that gives you nothing to inspect when it drops a task.

So the honest rule is to try the no-code route first, and write code only when you can name the specific thing it can't do.

## Common Todoist API errors and fixes

Few things go wrong with the Todoist API in production, and they're predictable. They're a bad token, a malformed parameter, a deleted ID, a rate limit, a retry that creates a duplicate, or an ID that changed between API versions.

Each has a known cause and a fix you can build in before launch. The table below puts all seven side by side, so the thing to take from it is that none needs guesswork once you've seen it.

| Error | Symptom | Usual cause | Fix |
|---|---|---|---|
| 400 | Request rejected with a validation message | Wrong parameter name, wrong type, or a malformed date or filter | Validate payloads before sending; log the response body, which names the offending field |
| 401/403 | Request refused | Expired, revoked or wrong token (401); token lacks access to that resource (403) | Re-read the token from storage; re-authorize rather than retrying |
| 404 | Resource not found | The task or project was deleted or completed elsewhere, or an ID from another version | Treat as "already gone" in cleanup paths; re-fetch before updating |
| 429 | Too many requests | Burst of calls, or a full sync run too often | Honor Retry-After, then back off with jitter |
| Duplicate after retry | Same task appears twice | Retried a create after a timeout that had actually succeeded | Send a request ID so the retry is recognized |
| Pagination cursor | Missing or repeated items | Cursor discarded, reused or built by hand | Pass back the cursor exactly as returned until none remains |
| ID change between versions | Lookups fail after a migration | Old and new API versions identify the same object differently | Store IDs as opaque strings and map old to new explicitly |

The sections below cover the four that need more than a table cell.

If you see a 401, the token is wrong, expired or revoked; a 403 means the token is valid but not allowed to touch that resource. Neither is transient, so retrying is wasted traffic.

Fail fast, alert, and re-authorize. A job that retries a 401 in a loop will burn through your rate budget while doing nothing useful.

On a 429, wait for the Retry-After header if present, and otherwise back off exponentially with random jitter so parallel workers don't retry in lockstep.

Full syncs are the tightest limit, so prefer incremental syncs and don't schedule a full one on a timer. Cap retries and queue the work instead of dropping it.

After a timeout, you can't tell whether the server created the task. If you retry a create blindly, you may get two.

Attach a unique request ID to every write so the retry is recognized as the same operation, and make your own records idempotent: store the ID you generated before sending, not after.

### Todoist API ID and pagination changes between versions

**Treat every ID as an opaque string**, never as a number you parse or compare. Between API versions the same object can carry a different identifier, so keep an explicit mapping during migration and expect a 404 where an old ID meets the new API.

For pagination, pass the returned cursor back untouched and stop only when none is returned; a hand-built or stale cursor is how items go missing or repeat.

Handle these seven before launch, and the integration stops being a surprise to the person on call.

## Todoist Automation with Activepieces

To connect Todoist to other apps without writing code, Activepieces gives you a workflow builder with 750 integrations and an MIT-licensed core, so most of your current toolchain is probably already integrated.

![Activepieces workflow builder displaying a three-step automation flow with a Typeform trigger, AI Agent, and Asana task…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/df365517-52b7-49cd-9eba-d658ef024bb7/marketing-to-sales-handoff-2026-automation-guide-89b95638.webp)

That covers the "first task in minutes" part of the problem and leaves the production-hardening part with you.

That distinction matters after the seven items above: a visual builder doesn't remove rate limits, ID handling or version changes. It moves where you deal with them.

### Create Todoist tasks from other apps

In Activepieces, a flow is a trigger followed by steps, and every plan, including free, allows unlimited flows.

The screenshot below shows the shape: a Typeform trigger labeled "New Submission", an AI Agent step, and an Asana action that creates a task, stacked vertically on the canvas.

Swap the Asana action for a Todoist one and you have the common pattern, a form response becoming a task.

Study the right panel, because it shows the trigger's configuration with required Connection and Form fields and an error reading "Throws an error, reconnect or refresh the page."

That message is what an expired or revoked connection looks like in practice, so someone has to own reconnecting it, or the flow stops creating tasks without anything else going wrong.

The panel also offers Generate Sample Data, Test Trigger and Use Mock Data, and mock data is useful for wiring steps together but proves nothing about how real payloads behave.

Next comes the question of what the builder can't do for you.

### Calling the Todoist API from a workflow step

When the Todoist integration lacks an action you need, an HTTP step lets you call the Todoist API directly with your own token. That's the route where the article's concerns come back to you in full.

![A workflow execution interface showing a completed two-step Square OAuth token revocation flow with HTTP configuration](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/ab58d76a-e150-4da2-b368-e9390d90658a/how-to-evaluate-telemetry-dev-llm-observability-bc2ee918.webp)

You choose the endpoint and version, so a deprecation is your problem to notice. You store the IDs a response returns, so mapping them between steps is on you.

And if a request is rejected for exceeding limits, nothing retries it unless you build that branch.

Activepieces doesn't replace that design work. It also doesn't make Todoist's behavior its own: limits and versioning remain Todoist's rules.

What it does change is who reviews the work: flows sync to git and move from a test environment to production through Release Management, so a pinned API version or a retry branch gets reviewed like code instead of living only in a vendor's UI.

![Activepieces workflow builder interface showing an untitled flow with webhook trigger and code step on the canvas, with…](https://ap-marketing-media.fra1.cdn.digitaloceanspaces.com/uploads/75d84a35-0942-43be-af8c-e501e7c0037c/n8n-workflow-history-retention-and-how-to-restor-c3dfff6e.webp)

Separate projects and environments make that promotion a deliberate step rather than a stray click on publish, and MoneyGram and Moneypenny run Activepieces in production.

Activepieces' own documentation covers Git Sync and Release Management, and the Ultimate plan's feature list names both alongside custom RBAC and audit logs, in the same product whether you self-host it or use the cloud.

Before you commit, check two things on the day you read this, 2026-11-22 or later. Activepieces' pricing page lists the credit-based plans, with unlimited flows on every tier, and Todoist is one of the integrations in the catalogue.

Both can change, and neither is something this article can vouch for.

## Pre-launch Todoist integration checklist

Limits and version behavior can change under you. Build so that a change shows up in your logs instead of in your users' tasks: seven steps, in this order, with failure handling ahead of the happy path.

The list runs from first request to a recurring check, and each step guards against a failure that a successful first call hides.

1. Create a token in a throwaway test account, not your own, so a runaway loop only clutters data nobody needs.
2. Run one curl request that creates a task and reads it back. That confirms auth and response shape before any SDK is involved.
3. Pick the API version explicitly and pin it in config, so a version change is a decision you make rather than a surprise.
4. Add retry with exponential backoff and jitter, and honor any wait hint the server sends. Pair it with idempotency: send a client-generated request ID where the endpoint accepts one, and where it doesn't, look up before you create. Otherwise a retried write can leave duplicate tasks.
5. Log every 429 with the endpoint, the caller and the retry outcome.
6. Store the token as a secret in your environment's secret store, never in the repo or a client bundle.
7. Set a calendar date to recheck the docs, and put an owner's name on it.

Those steps get one user's data flowing safely. A multi-user app can't collect personal tokens from everyone, so it needs OAuth, and it should treat each user's token as its own secret from the first commit.

### What to monitor after Todoist integration launch

Your 429 log is the early warning. A steady trickle means your pacing sits close to the limit, so queue and space requests before it worsens.

A burst right after a deploy points to a loop or fan-out you didn't intend, and more retries will only make it worse.

Also watch for retries that succeed on the second attempt but leave duplicates. That's idempotency failing quietly, and it won't show up as an error. Alert on unexpected response shapes and on deprecation notices too, since a version change rarely announces itself as an outage.

When the recheck date arrives, read the changelog against the version you pinned, fix what drifted, and set the next date.

## Frequently asked questions

The questions left over after pinning a version and scheduling a recheck mostly sit beside the Todoist API rather than inside it. Three of them are off-API, and each is worth one honest line:

- Free AI chatbots can work next to Todoist, but they're not part of the API and follow their own rules.
- AI-first code editors help you write API code, but they don't know which API version you pinned.
- Two-way Google and Outlook calendar sync is a separate integration job, not a Todoist API feature.

The answers below take those three, plus the two that stay on the API.

Is the Todoist API free to use? Yes, you can call it with a token from a free account, so cost isn't what stops you.

Some features depend on the plan behind the account, and rate limits apply to everyone, so a script that works in testing can still fail under load. Build retries and backoff in from the start.

### Can I use ChatGPT or another AI assistant with Todoist?

Yes, through a connector that gives the assistant tool access to your tasks, typically an MCP server entry in the assistant's config. That's off-API territory: you're trusting the connector, not your own pinned code.

Expect failures, such as the assistant guessing a project ID or retrying a create and leaving duplicate tasks. Keep it to your own account until you've seen it misbehave.

### AI-first code editors for API scripts

Which AI-first code editor suits Todoist API scripts? Pick whichever one lets you put the pinned version's docs in its context, because that matters more than the brand.

Left alone, an editor writes code from memory of older endpoints, which is how version drift gets into a new script. Read what it generates against the changelog before you run it.

### Syncing Google Calendar and Outlook

How do I sync Google Calendar and Outlook calendars? The Todoist API doesn't do two-way calendar sync, so you need a separate automation layer.

Activepieces, an MIT-licensed workflow tool with 25,670 GitHub stars, is one option for wiring calendars to each other and to tasks. Decide which side wins a conflict before you switch it on, or edits will overwrite each other.

### Webhooks

Does Todoist have webhooks? Yes. You register a webhook for your app and choose which events you want.

Verify the signature header on every delivery, and make your handler safe to run twice, because a retried delivery will otherwise create the same record again.

## Related reading

- [Todoist Google Calendar Integration: How to Sync (2026)](https://www.activepieces.com/blog/google-calendar-new-events-to-todoist-tasks)
- [Mattermost Automation: Integrations Guide (2026)](https://www.activepieces.com/blog/mattermost-automation-integrations-guide-2026)
- [How to handle errors in production AI agents](https://www.activepieces.com/blog/how-to-handle-errors-in-production-ai-agents)

## References

- [Datrise](https://datrise.com/en/integrations/source/todoist)
- [Todoist](https://www.todoist.com/pricing)
