Cursor Usage Limits: On-Demand Billing, Caps, and API Keys

Bottom line: how Cursor limits actually work

Cursor does not operate on a simple prompt counter. Its usage model combines included monthly usage pools priced at model API rates, on-demand usage billed in arrears, and background features that operate under distinct rules.

• Pro subscribers ($20/mo) receive a monthly amount of included model usage in two pools: one for Cursor models (such as Composer 2.5 and the Grok 4.x family) and one for other providers' models, charged at each model's API price.
• Model choice sets the pace: Because models have different API costs, a request to Claude Opus 5.5 ($4 input / $20 output per million tokens) uses included usage much faster than one to Composer 2.5 ($0.50 / $2.50).
• When included usage runs out, you can add on-demand usage and continue at the same API rates with pay-as-you-go billing in arrears, or upgrade to Pro Plus ($60) or Ultra ($200) for more included usage. Without a spend limit, automated agent loops can create unexpected monthly invoices.
• Cursor Tab completions are unlimited on Pro, Pro Plus, and Ultra and do not draw on model usage.
• Bringing Your Own Key (BYOK) routes supported requests to your provider account instead of Cursor's included usage.

Included vs on-demand usage: tier comparison matrix

The table below summarizes how limits and usage billing work across Cursor plans.

Understanding usage categories

Cursor handles different developer actions through distinct pipelines. Knowing which action draws from which pool prevents premature exhaustion of included usage.

1. Agent and chat requests (model usage)

Each prompt in the Agent or chat panel, and each inline edit, consumes model usage according to the model's API price and the tokens involved, including open files, repository context, and tool output.

• Requests to Cursor models such as Composer 2.5 draw on the Cursor-model pool, which has significantly more included usage.
• Requests to third-party models such as Claude Sonnet 5.5, Claude Opus 5.5, GPT-5.6 Sol, or Gemini 3.8 Flash draw on the other-models pool at each model's API price.
• Included usage resets monthly and does not roll over.

2. Auto mode routing

Auto mode chooses a model for each request in one of three modes: Cost, Balance, or Intelligence. Billing depends on the mode—Auto Cost uses its own bundled rate, while the other modes follow the routed model's pricing—so see Cursor router pricing and Auto mode before relying on it for budgets.

3. Background features: Cursor Tab and codebase indexing

A common misconception is that auto-completing code draws down your monthly usage.

• Cursor Tab: Cursor's predictive model suggests multi-line edits, variable renames, and bracket completions directly in the editor buffer. Paid subscribers receive unlimited Tab completions.
• Codebase embeddings and indexing: When you open a repository, Cursor computes embeddings of your files so codebase queries can locate relevant functions. This indexing runs in the background.

On-demand billing mechanics and spend limits

If you need to keep working after consuming your included usage, Cursor allows you to add on-demand usage.

How on-demand usage is calculated

On-demand usage continues at the same API rates as included usage and is billed in arrears. For example, an Agent request that reads 40,000 tokens of context and writes 2,000 tokens costs about $0.10 on Claude Sonnet 5.5 ($2 / $10 per million tokens), about $0.20 on Claude Opus 5.5 ($4 / $20), and about $0.03 on Composer 2.5 ($0.50 / $2.50).

Critical configuration: setting spend limits

To prevent unexpected credit card charges from runaway agent loops:

1. Open your Cursor account dashboard.
2. Find the on-demand usage settings.
3. Set a spend limit (e.g., $20 or $50) that stops paid usage once reached.
4. Monitor usage in the dashboard during intensive weeks, and consider Pro Plus or Ultra if on-demand spend is recurring.

Cursor Request Lifecycle Flow

Developer submits prompt in Agent or chat

• Is included usage available for the selected model's pool?
• • YES: Request runs against included usage
  • NO: Is on-demand usage enabled?
  • • YES: Within spend limit?
    • • YES: Request runs and is billed at API rates
      • NO: Request is blocked until the limit changes or usage resets
    • NO: Upgrade the plan, switch to a lower-cost model, or wait for the monthly reset

The Bring Your Own Key (BYOK) reality check

Many developers consider adding their personal Anthropic or OpenAI API keys into Cursor. While supported for some requests, this approach has specific technical and financial trade-offs.

What BYOK covers vs what it misses

• Covered: Supported chat and model requests to the provider whose key you configured.
• Not covered: Cursor Tab and Cursor's own models run on Cursor's infrastructure and cannot be pointed to external API keys.

Financial trade-off: API pricing vs Cursor plans

Cursor processes extensive context with every request, including open file buffers, linter diagnostics, recent diffs, and indexed symbols.

• A single Agent prompt with a 40,000-token repository context on Claude Sonnet 5.5 costs roughly $0.08 in input tokens alone on your personal API key.
• Ten multi-turn debugging prompts can easily cost $1.00 to $2.00 via direct API billing, and about twice that on Claude Opus 5.5.
• Because included usage is priced at the same API rates, the main advantage of a Cursor plan is the bundled usage, unlimited Tab, Cloud Agents, and Bugbot rather than cheaper tokens.

Teams usage and administration

In organizational deployments, Cursor Teams changes how usage is managed:

• Seat types: Standard seats cost $40 per user per month; Premium seats cost $120 per user per month with 5x the Standard Agent limits, so heavy users can get more capacity without upgrading everyone.
• Centralized spend controls: Team admins can set on-demand budgets, preventing individual developers from running up large bills.
• Privacy Mode enforcement: Team administrators can enforce Privacy Mode across developer machines.

Practical strategies when limits are reached

When your included usage runs out mid-sprint:

1. Switch to a lower-cost model: Use Composer 2.5 or Gemini 3.8 Flash for routine boilerplate, docstrings, and simple syntax fixes, conserving budget for complex architectural refactoring.
2. Use Auto in Cost mode: Let Auto handle routine requests at its cost-focused setting when you do not need a specific frontier model.
3. Set a reasonable $20 spend limit: Enabling on-demand usage with a strict cap funds roughly 200 Claude Sonnet 5.5 Agent requests of the size above, enough to finish an intense release week without unbounded financial exposure.