Cursor Usage Limits and Pricing Model Explained, Without Prices

Cursor does not give you a number of requests. On its current plans you get a monthly usage budget, measured in model cost, split into two pools: Cursor Models, for Cursor’s own models, and Other Models, for third-party models charged at that model’s API price. Every agent request draws from one pool or the other according to the model that handles it, so the model you pick decides how fast the budget goes. Usage resets with your billing cycle and does not roll over. When a pool runs out, Cursor shows a notification in the editor and you choose: turn on on-demand usage and keep going at the same API rates, or upgrade to a plan with more included usage. Tab completions are unlimited on the paid individual plans. This page describes Cursor’s own documentation as of September 30, 2026, and leaves the prices to Cursor’s pricing page.

The two usage pools

Cursor’s usage and limits page↗ (opens in a new tab) lists the pools:

• Cursor Models: Grok 4.7, Grok 4.6, Grok 4.5 and Composer 2.5. Cursor says this pool comes with significantly more included usage.
• Other Models: every third-party model, such as Anthropic’s, OpenAI’s and Google’s, charged at the model provider’s price.

By plan name: Pro, Pro+ (written Pro Plus on some pages) and Ultra include both pools, and the higher tiers include more of each. Start, a lower-cost plan for developers in India, covers only the Cursor Models pool, with no on-demand usage and no Auto. The free Hobby plan gives limited usage of Agent, Chat and Tab with the Auto model. Both pools appear in the editor’s settings and on the usage dashboard.

How a request is counted

A request costs what its tokens cost on the model that served it: input, cached input and output, at that model’s rate. That makes the pricing model easy to state and hard to predict. A short question to a small model barely registers; a long agent session on a frontier model, re-reading a large context on every turn, costs many times more. What moves the meter:

• The model. Third-party frontier models cost the most per token and come out of Other Models. Composer and Grok come out of the larger Cursor Models pool.
• Fast variants. Where a model offers a Fast mode, it is billed at a higher rate than standard.
• Context. Files, rules and earlier messages in the chat travel with each turn, so long chats cost more per message as they grow.
• Subagents. Cursor notes that subagents can run a named third-party model while the picker still shows Auto, Grok or Composer, and those requests bill Other Models.
• Cloud agents. Cursor’s cloud agent documentation says they are charged at API pricing for the selected model, and asks you to set a spend limit the first time you use them.

Max Mode, which widened a model’s context for an extra charge, belongs only to Cursor’s legacy request-based plans. If a guide talks about request counts or Max Mode, it describes the old model.

Auto and Cursor Router

Choose Auto instead of a named model and Cursor picks one per request. Its Cursor Router page↗ (opens in a new tab) says a classifier routes each request by task type and complexity, and you steer it with three optimization modes: Cost, which is what the old Auto became; Balance, the default for new users; and Intelligence, for complex multi-step work. Every Auto mode bills at the list price of the model the request was routed to, so an Auto request that lands on a third-party model draws from Other Models.

Cursor’s pages disagree on who has the router today. The pricing FAQ says it launches for Teams and Enterprise, with individual plans getting it a few months later; the models page says that on Teams and Enterprise the router picks the model for each Auto request; and the usage page describes it drawing from both pools without naming plans. If you are on an individual plan, check which Auto modes your model picker shows.

What happens when you reach the limit

According to Cursor’s page on usage-based charges↗ (opens in a new tab), you have three levers:

• On-demand usage: extra requests billed at API rates with no markup, on their own invoice lines. Individual plans must turn it on; Teams plans have it on by default. Cursor says on-demand requests are never downgraded in quality or speed.
• A spend limit: a monthly cap on on-demand charges. When it is reached, AI features stop for that user until the limit is raised or the next cycle starts. Enforcement is not instant, so usage can briefly pass the limit; Cursor credits that overage temporarily, and raising the limit in the same cycle can make it billable.
• An upgrade: a higher plan adds included usage without touching the spend limit.

With on-demand usage off, requests simply stop when the pool is empty and resume when it resets. Cursor’s spend limits page↗ (opens in a new tab) adds the team rules: on Teams, one team-level limit, and when it is reached everyone drawing on on-demand usage loses AI features; on Enterprise, admins can also set limits per member or per group, and the highest applicable limit wins. A toggle, Only Admins Can Edit Usage Settings, keeps members from changing those settings.

Teams, Enterprise and your own API key

• Teams seats come in two paid types, Standard and Premium, where Premium includes five times the Standard usage. Each seat’s usage belongs to that person, does not transfer to teammates, and resets with the team’s billing cycle.
• When a Teams member uses up their Other Models allowance, Cursor switches them to the Cursor Models pool; beyond that, on-demand usage applies if it is on.
• Enterprise can pool usage across the whole team instead of allocating it per seat.
• Teams and Enterprise also pay a per-token Cursor Token Rate on third-party model requests, including Auto requests routed to one. Cursor’s own models are exempt.

Bringing your own key changes the math by plan. Cursor’s API keys page↗ (opens in a new tab) says that on Pro, Pro+ and Ultra your provider bills you directly and those requests do not draw from either pool. On Teams and Enterprise the provider still bills the model cost, but the Cursor Token Rate applies and comes out of Other Models. Your own keys work only for chat models, since Tab always uses Cursor’s models, and Cursor’s Zero Data Retention policy does not cover requests made with them.

Where to check your usage

Open the Spending tab of the Cursor dashboard. It shows real-time usage for both pools, what is left, any on-demand charges and the reset date. Editor settings show both pools too. On Teams, admins see usage per member and can pull spending data through the Admin API.

Claude Code usage limits vs Cursor

The two meter differently, which is why comparisons get confusing. Cursor sells a monthly budget denominated in model cost. Claude’s Pro and Max plans use time windows: Anthropic’s Pro plan article↗ (opens in a new tab) says the session-based limit resets every five hours and a weekly limit applies across all models, with Max plans offering five or 20 times Pro’s per-session allowance. That allowance is shared between Claude and Claude Code, including Claude Code inside Cursor and other VS Code forks. You see it under Settings, Usage, or with /usage in a session; past it, you can turn on usage credits or wait for the reset. One trap: if ANTHROPIC_API_KEY is set in your environment, Claude Code uses it instead of your subscription and bills at API rates.

• Cursor: resets once per billing cycle, and at the limit you choose whether to keep going on-demand.
• Claude Code on Pro or Max: runs out for a few hours at a time, then comes back, with a weekly ceiling behind it.
• Both: the model and the size of the context decide how fast you get there.

The editors themselves are compared in Claude Code vs Cursor. OpenAI’s equivalent of this page is Codex usage limits.

Making the budget last

• Use Composer or Grok for routine edits and save third-party frontier models for the tasks that need them.
• On Auto, choose Cost for simple work and switch to Intelligence only for hard problems.
• Start a new chat for each task, so the agent is not resending an old conversation.
• Keep rules short and scoped, and switch off MCP servers you are not using; each one adds its tool list to the context. See MCP token usage.
• Set a spend limit before turning on on-demand usage, not after.

Scoped tasks spend less

The most expensive agent session is the one that starts by working out what you meant. A task that already says what, why and where, with a plan and a way to check the result, saves that exploration. That is what a fenbs task holds: a note with the problem, a plan with the steps, and a test status with notes once it is done, on a board with lanes To Do, Next Up, In Progress and Completed that your team and your AI assistants share. Add https://fenbs.ai/api/mcp to .cursor/mcp.json, and Cursor’s agent can read the task with fenbs_get_item before it starts and record what it did with fenbs_update_item, and History shows each change under the assistant’s name. fenbs has no due dates or sprints; it keeps the list, not the schedule.