Track Cursor plan usage in the official dashboard at cursor.com/dashboard/usage. Paid plans separate Cursor Models from Other Models: Cursor’s own models have a generous included pool, while third-party models draw from a dollar-denominated allowance. Tab is unlimited on paid individual plans and limited on Hobby. Pro includes $20 of Other Models usage, Pro Plus $70, and Ultra $400, while Cursor describes their Agent capacity as Pro, 3x Pro, and 20x Pro. Cursor does not publicly publish prices for Pro Plus or Ultra. When included third-party usage is spent, on-demand billing can keep requests running at model API rates. If you also run Claude Code, Codex, and other agents, Continuum’s local analytics put Cursor session history in the same repo, provider, model, and daily ledger, beside live quota gauges for connected providers. Cursor’s dashboard remains the authority for Cursor plan pools and billed overage.
- Use Cursor’s official usage dashboard for the plan allowance, remaining pool, and on-demand activity tied to your account.
- Paid plans have two model pools: Cursor Models and Other Models. They do not drain the same balance.
- Tab is unlimited on Pro, Pro Plus, and Ultra. It is limited on the free Hobby tier.
- Pro, Pro Plus, and Ultra include $20, $70, and $400 respectively for third-party models.
- Cursor publishes no public Pro Plus or Ultra price. The 3x and 20x figures describe Agent limits, not list prices.
- For several agents, pair vendor dashboards with a per-repo local ledger. One view cannot answer both quota and attribution.
Start with the four meanings of Cursor usage
A usage number is only useful when you know what it measures. Cursor has changed billing models several times, so search results mix current pools with old request counts and older credit language. The present model is easier to reason about once the meters are separated.
The four questions people collapse into “Cursor usage.”
| Meter | What it answers | Where to read it |
|---|---|---|
| Tab completion | How much predictive editing is included | Plan terms; unlimited on paid individual plans, limited on Hobby |
| Cursor Models pool | Use of Composer 2.5 and Cursor Grok 4.5 | Cursor usage dashboard |
| Other Models pool | Dollar-valued use of models from Anthropic, OpenAI, Google, and others | Cursor usage dashboard |
| On-demand spend | Usage after the included third-party allowance | Cursor usage and billing dashboard |
These are not interchangeable. A day with hundreds of accepted Tab edits can leave the Other Models pool untouched. One long Agent run on a pinned frontier model can consume more of that pool than a week of completions. A request may also be throttled for a short period without the monthly allowance being empty. “I hit a Cursor limit” is a diagnosis to begin, not a diagnosis to finish.
How Cursor usage works on the current plans
Every paid individual plan includes the same broad product: the editor, unlimited Tab, Agent, cloud agents, and access to models. Higher tiers primarily buy more usage. Hobby is the evaluation tier and behaves differently because its limits are intentionally small and Cursor does not publish a fixed request count.
Allowances from the site’s Cursor pricing sources, checked August 2026. Prices for Pro Plus and Ultra are not publicly published.
| Plan | Tab | Cursor Models | Other Models | Agent capacity |
|---|---|---|---|---|
| Hobby | Limited | Limited | None | Limited, no published request count |
| Pro | Unlimited | Generous included usage | $20 | Baseline |
| Pro Plus | Unlimited | Generous included usage | $70 | 3x Pro limits |
| Ultra | Unlimited | Generous included usage | $400 | 20x Pro limits |
| Teams Standard | Included | Included | Per-seat allowance | Standard team limits |
| Teams Premium | Included | Included | Per-seat allowance | 5x Standard limits |
The dollar figures in the Other Models column are allowances, not plan prices. Pro costs $20/mo. Cursor does not publicly publish a dollar price for Pro Plus, Ultra, or Teams Premium as of August 2026. The signed-in plan picker is the only current figure to use for upgrade arithmetic. The full public ladder and the reasons older pages disagree are covered in Cursor AI price.
The Cursor usage dashboard, step by step
The official account page is cursor.com/dashboard/usage. Sign in with the same Cursor account the editor or CLI uses. This is the authority for the allowance attached to that account, because public plan pages cannot know your billing date, current tier, legacy status, or on-demand activity.
Confirm the account and billing period
Before reading a percentage, verify that the dashboard account is the account running the sessions and note the period it covers. A work account open in the browser and a personal account in the editor produce perfectly plausible but useless numbers.
Read the pools separately
Find the Cursor Models usage and the Other Models allowance. Do not add them into one imagined balance. An empty third-party pool does not mean Composer or Tab has no capacity, and a healthy first-party pool does not make frontier-model calls free.
Check on-demand activity
If the included third-party allowance is spent, determine whether on-demand usage is active and how much has accrued. Cursor documents that on-demand requests continue at the same API rates rather than being downgraded in quality or speed.
Compare the selected model with the draining pool
Open Cursor’s model setting and identify the current route. A third-party model should explain movement in the Other Models pool. A first-party Cursor model should explain movement in the Cursor Models pool. A mismatch is a reason to inspect Auto mode or another session, not to guess.
Record a weekly snapshot
Once a week, record the remaining allowance, on-demand spend, dominant model, and the repositories that had large agent runs. Four numbers over four weeks are more useful than checking the page only after a limit interrupts you.
What consumes each pool
The fastest way to control usage is to route work to the right surface. Cursor’s editor features and model routes have very different economics even when they produce similar visible code.
| Action | Primary meter | Practical consequence |
|---|---|---|
| Tab completion on a paid plan | No metered model pool | Use it freely for mechanical editing and propagation |
| Composer 2.5 or Cursor Grok 4.5 | Cursor Models pool | Preserves the dollar-denominated third-party allowance |
| Pinned Anthropic, OpenAI, Google, or other third-party model | Other Models pool at that model’s API rate | Expensive models and long context drain the allowance faster |
| Auto Cost | Other Models pool at a flat per-million-token rate | Optimizes for predictable cost across the route |
| Auto Balance or Auto Intelligence | Other Models pool at the selected model’s API rate | The routed model determines the cost |
| On-demand continuation | Monthly billed overage | The task continues after included third-party usage is spent |
Agent work is expensive because the visible answer is only the final step. The model reads files, receives search results, runs commands, receives command output, may read more files, edits, runs tests, and sends those results through the loop again. Larger repositories and longer sessions increase the material carried forward. Tab usually predicts a small edit from local context and therefore belongs to a different cost class.
Usage limits, rate limits, and context limits are different
The phrase “Cursor rate limit” gets used for three separate boundaries. Treating them as one leads to the wrong fix.
| Limit | What reached a ceiling | What to do |
|---|---|---|
| Plan usage limit | An included Cursor Models or Other Models allowance | Change route, add on-demand usage, wait for the plan period, or compare an upgrade |
| Short-term rate limit | Requests are arriving faster than a service or model currently accepts | Wait, reduce parallelism, retry later, or choose another available model |
| Context limit | The active task carries more text or tool output than the model can accept | Start a focused session, reduce scope, summarize, or remove irrelevant files |
A plan limit is economic. A short-term rate limit is about request velocity or temporary capacity. A context limit belongs to one task and model. Upgrading the monthly plan may help the first, may not help the second, and does not make an unbounded conversation well scoped. Read the wording of the error and inspect the dashboard before changing a subscription.
- If the dashboard pool is empty, the account used its included capacity. Decide between routing, on demand, and a tier change.
- If the dashboard has room but requests fail briefly, suspect a transient rate or service condition. Check whether Cursor is down before changing billing.
- If one long thread fails while a fresh task works, suspect context size or accumulated tool output. Start a smaller, explicitly scoped session.
- If only one model fails, switch to another available route and check the provider or Cursor status before treating the whole account as limited.
What happens when Cursor usage runs out
Cursor’s current model is designed to avoid silently degrading an expensive request into a worse one. When the included third-party allowance is spent, you can add on-demand usage and continue at the same model API rates, billed monthly, or move to a plan with more included usage. Cursor states that on-demand requests are not downgraded in quality or speed.
| Choice | What you gain | What you risk |
|---|---|---|
| Use first-party Cursor models | Keep working inside the separate Cursor Models pool | The model may not be the one you originally selected |
| Enable or continue on demand | No interruption at the third-party allowance boundary | The invoice can exceed the plan price |
| Upgrade | More included Agent and third-party capacity | Pro Plus and Ultra prices must be read from the current plan picker |
| Wait for the next billing period | No extra spend | The task is delayed |
| Move the task to another agent plan | Uses capacity you may already own elsewhere | A second workflow and a second usage meter |
The correct answer depends on whether the event is exceptional. One unusually large migration does not justify a permanent tier. Repeating the same overage for two or three periods probably does. Compare the current upgrade price with actual on-demand spend, not with an estimated token count from someone else’s repository.
A weekly Cursor usage routine that takes five minutes
- Open the official usage dashboard. Record remaining Cursor Models capacity, remaining Other Models allowance, and current on-demand spend.
- Check the model selector. Write down whether the default is a Cursor model, Auto Cost, Auto Balance or Intelligence, or a pinned third-party model.
- Name the two largest agent tasks. Repository, rough duration, and whether they used parallel agents. You are looking for causes, not perfect accounting.
- Compare week over week. A single absolute number says little. A pool draining twice as fast after a model or repository change is actionable.
- Make one routing decision. Keep the current route, move ordinary tasks to a first-party model, or reserve the frontier model for a named class of work.
- Review overage against upgrade price monthly. Cursor does not publish the higher-tier price publicly, so use the signed-in figure and actual billed usage.
This routine deliberately avoids tokens as the primary unit. Cursor bills different models at different rates, and a million cheap tokens is not equivalent to a million expensive ones. Dollars by pool and the work that caused them are the shortest route to a decision.
The multi-tool reality: quota and cost need two views
Cursor’s dashboard is complete for Cursor and structurally blind to every other tool. Claude Code cannot see Codex usage. Codex cannot see a Cursor agent session. An API provider sees tokens and knows nothing about the repository outcome. This is not a vendor failure; each dashboard owns a different boundary.
| Question | Best source |
|---|---|
| How much Cursor plan allowance remains? | Cursor usage dashboard |
| What Cursor on-demand usage will Cursor bill? | Cursor billing dashboard |
| Which repository and model produced local Cursor session spend? | Local session analytics |
| How does Cursor work compare with Claude Code and Codex on the same repo? | Cross-agent local ledger |
| Can I start a heavy provider session without exhausting a live quota window? | Live provider gauge |
This distinction prevents false precision. A local ledger prices recorded model events against its rate snapshot and attributes them to work. A vendor invoice applies the vendor’s billing contract, credits, taxes, discounts, and account policy. Use the first to change engineering behavior and the second to reconcile cash.
Diagnosing unexpectedly high Cursor usage
High usage usually has a mechanical explanation. Work through these causes in order before changing plans.
Check the pinned model
A frontier third-party model draws the Other Models pool at its API rate. If the account used to route through a Cursor model or a cheaper Auto mode, one settings change can explain the entire slope.
Check repository and context size
A broad request in a large monorepo makes the agent search, read, and carry far more material. Name files, directories, tests, and the acceptance boundary instead of asking the agent to “fix everything.”
Check parallel and cloud runs
Two agents consume independently even when they attack the same problem. Best-of-N is useful only when the value of a better branch exceeds the cost of producing branches you will discard.
Check retries and failing commands
A test that repeatedly fails for an environmental reason can feed the same long output through several turns. Stop the loop, diagnose the environment, and resume from a clean statement of facts.
Check for on-demand continuation
The included allowance may already be spent while work continues normally. That is the intended on-demand behavior, so the absence of an interruption does not mean the plan still covers the run.
Team tracking without turning it into surveillance
A team needs enough usage data to control spend and improve routing, not a leaderboard of who typed the most. The useful grain is repository, model, period, and outcome.
- Assign an owner for on-demand policy. Someone decides whether overflow is allowed, reviews the monthly amount, and compares it with the current Premium seat price.
- Track by repository before person. A migration repo and a mature service have different legitimate costs. Per-person totals hide that context and reward rationing.
- Separate first-party and third-party routes. A team pinned to frontier models needs a different budget from one using Composer for ordinary work.
- Measure finished outcomes. Cost per merged pull request, fixed incident, or completed migration can support a decision. Raw tokens and session counts cannot.
- Account for the Teams token surcharge. Cursor’s current pricing reference adds $0.25 per million tokens to third-party model requests on Teams and Enterprise, while Auto Cost and first-party Cursor models are exempt.
- Keep vendor billing as the reconciliation source. Local analytics support engineering decisions; the Cursor invoice closes the books.
Teams Standard is $40/user/mo, or $32/user/mo at the published annual rate. Teams Premium has 5x Standard Agent limits, but Cursor does not publish its price publicly. Buy a team tier for administration, SSO, billing, and policy as well as capacity. If capacity alone is the problem, compare actual overage with the live plan-picker figure before changing every seat.
The shortest correct tracking stack
| If you run | Use |
|---|---|
| Only Cursor | Cursor usage dashboard weekly, billing dashboard monthly |
| Cursor plus one terminal agent | Both vendor dashboards plus a small repo and outcome log |
| Cursor, Claude Code, Codex, and more | Vendor dashboards for limits and invoices, plus Continuum or another cross-agent local ledger for repository attribution |
| A team | The same stack, with an explicit on-demand owner and a monthly route review |
There is no honest single number for every question. Cursor’s dashboard tells you what Cursor will allow and bill. Local history tells you what work created the modeled cost. Provider gauges tell you whether a time window has room right now. Keep those units separate and Cursor usage becomes an operating input rather than a monthly surprise.
If the measurement shows the editor is still earning its seat but the agent operation is not, read the Cursor alternatives roundup. The answer may be to keep Tab and move the long-running sessions, not to replace the editor wholesale.
Questions people ask
Sign in at cursor.com/dashboard/usage with the same account used by the editor or CLI. Read the Cursor Models pool, the Other Models dollar allowance, and any on-demand activity separately. The dashboard is account-specific and is the authority for current plan usage.
Hobby has limited Tab and Agent usage with no fixed public request count. Paid individual plans have unlimited Tab, a generous Cursor Models pool, and an Other Models allowance of $20 on Pro, $70 on Pro Plus, and $400 on Ultra. Agent capacity is described as Pro, 3x Pro, and 20x Pro respectively.
Yes, but “rate limit” can mean a spent plan allowance, a short-term request throttle, or a model context boundary. Check the dashboard and the exact error. An empty plan pool calls for routing, on demand, waiting, or an upgrade; a transient throttle usually calls for waiting or reducing parallel requests.
Tab is unlimited on Pro, Pro Plus, and Ultra and does not draw the Cursor Models or Other Models pool. It is limited on Hobby. Agent work on first-party Cursor models draws the Cursor Models pool, while third-party models draw the dollar-denominated Other Models allowance.
For third-party model usage, you can continue on demand at the same API rates or upgrade for more included capacity. Cursor states that on-demand requests are not downgraded in quality or speed. If on demand is not the policy you want, move to a first-party route or wait for the next period.
Pro includes unlimited Tab, generous use of Cursor’s own models, and a $20 monthly allowance for third-party models. It is the baseline Agent tier. Cursor describes Pro Plus as 3x Pro limits and Ultra as 20x Pro limits, but does not publicly publish their prices.
Continuum’s analytics product page lists Cursor as one of eight local analytics columns and says Cursor session history rolls into aggregate spend, the by-repo split, and the by-model leaderboard. Use that for cross-agent repository attribution. Use Cursor’s official dashboard for Cursor plan pools, on-demand billing, and the final invoice.
Check the selected model first, then repository scope, long context, parallel agents, repeated failing commands, and on-demand continuation. A pinned expensive model or one broad agent task can drain the Other Models pool much faster than Tab and first-party Cursor model work.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.