
Your agent is halfway through a Jira cleanup or a Notion import, and the next tool result says rate limited. Retrying makes it worse, and you can't tell whose limit it is: Jira's, the MCP server's, or your Claude plan's.
An MCP rate limit error comes from one of three places: the app's API, the app's MCP server, or your AI client's usage plan. Read the error to find out which, check that provider's documented limit, then make your agent do fewer, larger, slower, and safer calls.
Arc0 publishes this blog. It shows up near the end as the worked example, and every fix in the fixes section works whatever you connect through.
Three places a rate limit can come from
MCP, the Model Context Protocol, is how an assistant like Claude or Cursor talks to outside apps. Each thing a server offers (search pages, create an issue) is a tool, and each time the model uses one is a tool call. A 429 is HTTP's "too many requests" status, the one Notion, Jira, Figma, and ClickUp send when you're over.
One tool call can be counted in three places, and each keeps its own meter.
- The provider's API. Notion, GitHub, Jira, Figma, and ClickUp each limit requests to their API, whoever sends them. Your agent is just another caller.
- The vendor's MCP server or hosted connector. Some vendors add a meter on the MCP endpoint. Notion MCP counts every tool call against the standard API limits and has its own
mcp_tool_rate_limitreason. Figma MCP has caps of its own, and so does ClickUp MCP unless you have its Everything AI add-on. - Your AI client's plan. Claude Code, claude.ai, and Cursor meter your model usage, not any app's. When Claude Code hits your plan limit, it tells you so and names a reset time.
Many "MCP rate limit" errors aren't MCP's at all. They're the app's API or your plan, and the MCP server is just the messenger holding the bad news.
Reinstalling the server won't fix a limit that lives in your Claude subscription.
The MCP spec adds a wrinkle. Tool execution errors reach the model as a tool result marked isError: true, not as an HTTP status, and the spec says servers must rate limit tool invocations. So the error you're hunting often arrives as a line of text inside a tool result, and which text you see depends on your client.
Read the error: which one did you hit?
The error text usually names its owner, if you know where to look. Our rule of thumb, not any vendor's: a message that names your plan, its usage window, or your session or weekly limit means your client; a provider's code or header means that provider's API or its MCP server. If you see neither, open the full tool result and read the raw text.
| Signal you see | Whose limit | First move |
|---|---|---|
| "You've hit your session limit · resets 3:45pm" (or "weekly limit") | Your Claude plan | Wait for the reset; changing the MCP setup won't help |
| "Server is temporarily limiting requests (not your usage limit)" | A short API throttle, not your plan | Claude Code retries with backoff on its own |
| "Request rejected (429)" | The limit on your API key, Amazon Bedrock project, or Google Cloud project | Lower concurrency, such as fewer parallel subagents |
| Repeated "529 Overloaded" | Capacity, not quota | Wait; it doesn't count against your quota |
rate_limited, or the reason mcp_tool_rate_limit | Notion's API or Notion MCP | Wait the retry_after_seconds it gives, cut parallel calls |
x-ratelimit-remaining: 0, or a 403 or 429 from GitHub | GitHub's API | Wait until x-ratelimit-reset |
RateLimit-Reason: jira-... or conf-... | Jira or Confluence, and the value says which limit | Match the fix to the reason |
X-Figma-Rate-Limit-Type | Figma, by seat type | Check your seat before you retry |
429 with X-RateLimit-* from ClickUp | ClickUp's API | Wait for X-RateLimit-Reset |
Cursor and claude.ai connectors are harder to read. We found no documented error wording for either (checked November 2026). Cursor says you'll see a notification in the editor, and its usage-limits page doesn't mention MCP at all. Claude's paid plans have a session limit that resets every five hours, plus weekly limits, both shown under Settings > Usage. Claude's help also notes that tools and connectors are token-intensive and count toward your usage. If you're setting a client up from scratch, the steps are in Arc0 MCP for Claude and Arc0 MCP for Cursor.
The tone is a hint, not a rule: a plan tends to talk to you in a sentence about your usage, while a provider talks in codes and headers, some counting seconds to wait and some naming a reset time.
Documented limits by provider
Each vendor publishes its own numbers, and some publish none for their MCP server. Every figure here comes from the vendor's own docs. Find your app's row, then read its section for the signal and the fix.
| Provider | API limit | MCP limit | Look for |
|---|---|---|---|
| Notion | 600 a minute on Business and Enterprise, 180 on other plans | The API's limits; every tool call counts | rate_limited, mcp_tool_rate_limit |
| GitHub | 5,000 an hour per user token; 100 concurrent requests | None documented | x-ratelimit-remaining: 0, 403 or 429 |
| Jira and Confluence | 65,000 points an hour in the global pool; per-tenant tiers | Not published; Teamwork Graph tools use Rovo credits | RateLimit-Reason |
| Figma | By tier and seat type; on View or Collab, Tier 1 is per month, Tiers 2 and 3 per minute | 20 a month on View or Collab; per day and per minute on Full or Dev | X-Figma-Rate-Limit-Type |
| ClickUp | 100 to 10,000 a minute per token | The API's with Everything AI; otherwise 100 to 25,000 per rolling 24 hours | 429 with X-RateLimit-* |
Notion API and Notion MCP rate limits
Notion MCP has no limit of its own: it spends your Notion API budget, and every tool call counts toward it. As of November 2026, that budget is 600 requests a minute per connection on Business and Enterprise, and 180 a minute on other plans. Querying a data source is held to about 3 requests a second, and a per-workspace limit with no published number sits on top.
When you're over, you get rate_limited, and additional_data.rate_limit_reason names the limit. Retry-After comes in whole seconds: at most 60 for the per-connection limit, usually under 10 for mcp_tool_rate_limit. Notion MCP retries a limited call once, and only when the wait is 2 seconds or less; otherwise your agent gets a tool error with retry_after_seconds in it.
What to change: Notion's own advice is to ask your assistant to reduce parallel operations or try again later. Several subagents querying one database all share that connection's 3 requests a second, so they hit the same cap together.
Parallel subagents on one Notion database don't go faster; they take turns being told no.
GitHub MCP rate limits: REST, GraphQL and the MCP server
The GitHub MCP server's README documents no rate limit of its own, so the limits you'll hit are GitHub's API limits (our inference). As of November 2026, the REST API allows 5,000 requests an hour for a personal access token, and 15,000 for Enterprise Cloud organizations. GraphQL counts points instead, 5,000 an hour per user.
Five thousand an hour sounds like plenty, and for one person it usually is. The secondary limits are the ones agents tend to trip, because agents fan out: no more than 100 concurrent requests, and 80 content-generating requests a minute or 500 an hour. When you're limited, GitHub returns a 403 or 429, and the primary limit shows x-ratelimit-remaining: 0.
GitHub spells out the retry order. Wait the retry-after seconds if they're given. If remaining is 0, wait until x-ratelimit-reset, which is in UTC epoch seconds. Otherwise wait at least a minute, then back off exponentially and stop after a set number of tries; keep hammering while limited and your integration may be banned. The README also offers --toolsets, and says enabling only the toolsets you need helps with tool choice and reduces context size.
If your agent comments on every pull request in one burst, the secondary limit will notice before you do.
Atlassian MCP rate limits: Jira, Confluence and Rovo MCP
As of November 2026, the Atlassian pages we checked publish no rate limit for its Rovo MCP server, so our reading is that Jira's and Confluence's APIs are where you'll be throttled. The support page states no limit or quota, and says enriched Teamwork Graph tool calls through the server consume Rovo credits. An open issue on Atlassian's MCP repository asks for hard numbers, and Atlassian's replies haven't given any.
Jira Cloud enforces three separate limits: an hourly quota, per-second bursts, and writes to a single issue. Break any of them and you get a 429; use up the hourly quota and every request is denied until the next hourly reset. The quota is counted in points rather than raw requests. Tier 1, the default, is a global pool of 65,000 points an hour, and Tier 2, after Atlassian's review, gives each tenant (each customer's site) its own quota, capped at 500,000. Confluence uses the same points model. Writes to one issue are held to 20 per 2 seconds and 100 per 30 seconds.
The RateLimit-Reason header tells you which wall you hit: jira-quota-global-based, jira-quota-tenant-based, jira-burst-based, or jira-per-issue-on-write, and conf-global-based or conf-tenant-based for Confluence. X-RateLimit-NearLimit turns true when under 20% remains, a polite warning before you're out.
What to change: batch with bulk operations and merged field updates, and on jira-per-issue-on-write, pause writes to that issue only. A common way to hit that one is an agent fixing a ticket in a tight loop, every small correction its own write.
And don't find your number by hitting it: Atlassian asks you not to run rate-limit tests against cloud tenants.
Figma MCP rate limits and the REST API
Figma's MCP server has caps of its own, and your seat decides them. As of November 2026, a View or Collab seat gets up to 20 tool calls a month, on every plan including Starter. Full and Dev seats get 200 a day and 10 a minute on Professional and Education, 200 a day and 15 a minute on Organization, and 600 a day and 20 a minute on Enterprise. The caps apply to tools that read from Figma; tools such as create_new_file and generate_figma_design are exempt, and Figma may change the limits at any time.
Figma's REST API uses a leaky bucket: your requests fill it, it drains at a steady rate, and a burst that overflows it gets a 429. That response carries Retry-After and X-Figma-Rate-Limit-Type, which reads low for Collab and Viewer seats and high for Full and Dev. On View and Collab seats, Tier 1 endpoints allow up to 20 a month, Tier 2 up to 5 a minute, and Tier 3 up to 10, and Figma adds that the actual limit may be lower.
No backoff schedule turns a monthly allowance into a daily one: on a View seat, the fix is a seat, not a retry.
ClickUp MCP rate limits and the ClickUp API
ClickUp MCP's limit depends on one add-on. With Everything AI, it matches the Public API's limit for your plan. Without it, as of November 2026, each workspace and client gets a rolling 24-hour cap: Free Forever 100, Core/Unlimited 300, Business 1,000, Business Plus 2,500, Enterprise 5,000, and Enterprise Plus 25,000. Each tool call counts as one, the window starts with your first request, and the limits cannot be reset; ClickUp says they may change.
The API itself allows 100 requests a minute per token on Free Forever, Unlimited, and Business, 1,000 on Business Plus, and 10,000 on Enterprise and Enterprise Plus. Go over and you get a 429 with X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset; the page gives no retry guidance.
"Cannot be reset" is a phrase to read before the big import, not after.
Fixes that make the task finish
These work whatever your agent connects through. Most are the vendors' own rules; searching before fetching, caching within a task, and spreading jobs across windows are our recommendations.
- Wait for
Retry-After, then back off. Atlassian says to treat the stated wait as the minimum, then back off exponentially with jitter (a random spread, so parallel workers don't retry in lockstep) and cap your retries. GitHub also says to back off exponentially and stop after a set number of tries, and Notion and Figma sendRetry-Aftertoo. - Lower concurrency. Notion's advice is fewer parallel operations, and Claude Code's fix for a 429 includes fewer parallel subagents. GitHub asks for serial requests, with at least one second between writes.
- Read fewer, larger pages. Ask for the maximum page size: 100 in Notion, and
firstup to 100 in GitHub's GraphQL. Search first, then fetch only the items you need. - Cache within the task. Don't let your agent re-read a page or issue it already has in this run. On GitHub, a conditional request that returns 304 doesn't count against the primary limit.
- Batch writes. Use Atlassian's bulk operations and merged field updates, and on
jira-per-issue-on-write, pause only that issue. - Spread a job bigger than one window. On a Full or Dev seat, Figma's MCP caps are per day, so a job larger than a day's allowance has to run across days. ClickUp's rolling 24-hour window can't be reset, so whatever's left waits for the next window.
- Use events instead of polling. GitHub says to subscribe to webhook events instead of polling, and if you must poll, to wait at least the
x-poll-intervalseconds. - Never resend a write whose outcome you don't know. A rejected request generally wasn't processed, so that retry is the easy case. The hard case is a write that timed out, because the first attempt may have landed. Atlassian says to retry only idempotent requests that come back with
Retry-After. For anything else, check whether it landed before you try again. - Watch tool output size. Claude Code warns above 10,000 tokens of MCP tool output and caps it at 25,000 by default;
MAX_MCP_OUTPUT_TOKENSchanges that. A huge read costs your context as well as the provider's quota.
The one that hurts is the write rule. Picture it: the call to post a comment times out, your agent tries again, and now the ticket says "Fixed in the latest build" twice.
Paste something like this at the start of a long task, and it hands your agent most of the list:
Work through this task serially, one tool call at a time.
Use the largest page size each tool allows, and search before you fetch.
Don't re-read anything you've already read in this task.
If a tool returns rate_limited or a 429, stop, wait the number of seconds it gives, then continue.
If a create, update, or comment times out or fails unclearly, check whether it landed before you try it again.Where Arc0 helps around the limit
A service like Arc0 sits between your agent and its apps: it holds the credentials and makes the calls. What it can't do is make an app's limit bigger. Nothing in between raises it, whether you reach Notion, GitHub, Figma, or your project-management apps through Arc0. The provider's limit still applies, and usage on your own provider credentials is billed by that provider.
Arc0 handles the things around the limit instead: how writes run, how many tools your agent sees, and the record of what it called.
- Writes with keys and receipts. Arc0's execution uses idempotency keys and receipts, and its clients never retry writes automatically. No hidden retry in the client sends a write a second time, which matters most in the timed-out case above; whether to try again stays your agent's decision. The execution helpers also include governed batches.
- A short tool list. Instead of loading every tool from every app, your agent searches a short list of the actions it's authorized to use with
search_actions, then runs one withexecute_action. It's similar in spirit to GitHub's toolsets advice, applied across your apps: fewer tool definitions in context, and less for the model to choose wrong from. See Arc0 MCP. - A record of calls. The audit log is on every plan, kept 7 days on Personal, 30 on Build, 90 on Launch, and 365 on Scale. Calls to official vendor MCP servers that Arc0 proxies still go through it.
- Events instead of polling. You can subscribe to app events, GitHub's among them, with signed, durable, replayable delivery, so your agent stops asking every few minutes whether anything changed (events).
Waiting, pacing, and caching stay with your agent or your code, as in the fixes above.
Notion's limit stays Notion's; what Arc0 changes is that Arc0's clients don't re-send a write on their own.
Name the source, read the signal, change the pattern
A rate limit in an MCP setup belongs to the app's API, the app's MCP server, or your AI plan, and the error text usually says which. Match the fix to the owner: wait out a plan, slow down for an API, and never resend a write you can't account for.
Arc0 is our pick for the part around the limit: execution uses idempotency keys and receipts, your agent searches a short authorized tool list, and the audit log is on every plan, kept 7 to 365 days. To try it, get a free personal MCP URL from Arc0 for individuals, connect the app that keeps throttling you, and add the URL to your client with the MCP client setup guide.
Then run the same task again, slower and serially, and read the audit log when it's done.