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 priority allocations, graceful queue fallbacks, on-demand usage billed in arrears, and background infrastructure services that operate under distinct rules.

• Pro subscribers ($20/mo) receive 500 Fast Requests per billing cycle, which route to frontier models (Claude 3.7 Sonnet, Claude 3.5 Sonnet, GPT-4o) with near-instant execution.
• When Fast Requests reach zero, your editor does not freeze. Instead, requests fall back to Slow Requests (free, queued during peak hours) unless you have explicitly enabled On-Demand Usage.
• On-Demand Usage allows work to continue seamlessly at fast speeds, but usage is billed in arrears at roughly \$0.10 per request (or direct model token pass-through). Without a hard spend cap configured in your dashboard, automated agent loops can create unexpected monthly invoices.
• Cursor Tab (Copilot++) and codebase indexing run on Cursor's proprietary custom infrastructure and are unlimited for Pro users. They do not consume your 500 Fast Requests or trigger on-demand charges.
• Bringing Your Own Key (BYOK) only powers standard chat and inline editing. It cannot power Cursor Tab or semantic codebase embeddings.

Fast vs Slow vs On-Demand: tier comparison matrix

The table below details how limits, queues, overage costs, and background services function across Cursor plans.

Understanding request categories

Cursor handles different developer actions through distinct compute pipelines. Knowing which action draws from which pool prevents premature quota exhaustion.

1. Fast priority requests (the 500 allocation)

Each time you submit a prompt in the Cursor Chat sidebar, trigger an agentic workflow in Composer (Cmd+I), or request a major refactoring via inline edit (Cmd+K) using a frontier model like Claude 3.7 Sonnet or GPT-4o, you consume 1 Fast Request.

• The 500-request quota resets on your monthly billing date, not the first day of the calendar month.
• Lightweight model interactions (such as cursor-small) do not consume Fast Requests on paid tiers.
• Unused Fast Requests expire at the end of the billing cycle; they do not roll over into subsequent months.

2. Slow requests: queue mechanics and peak-hour latency

Once your 500 Fast Requests are exhausted, Cursor switches to Slow Requests by default.

• Slow requests query the exact same frontier models with the identical context window and response quality.
• The difference lies entirely in execution priority: during low-traffic windows (evenings and weekends), slow requests often execute in 2 to 4 seconds, virtually indistinguishable from fast requests.
• During global developer peak hours (US and European business hours), slow requests enter a central queue, resulting in wait times ranging from 15 to 45 seconds per response.
• For interactive Composer runs that require ten consecutive iterations, queuing delay can interrupt developer momentum, which is why many engineers choose on-demand extensions.

3. Background services: Cursor Tab and codebase indexing

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

• Cursor Tab (formerly Copilot++): This custom predictive model suggests multi-line edits, variable renames, and bracket completions directly in the editor buffer. It runs locally and on low-latency dedicated edge workers. Pro subscribers receive unlimited completions.
• Codebase embeddings and indexing: When you open a repository, Cursor computes vector embeddings of your files so @codebase queries can locate relevant functions. This indexing runs continuously in the background at no extra charge.

On-demand billing mechanics and spend caps

If you need uninterrupted fast responses after consuming your 500 included requests, Cursor allows you to toggle on-demand billing in your account settings.

How on-demand usage is calculated

On-demand requests are billed in arrears at the end of your billing cycle.

• Standard frontier model requests (such as Claude 3.5 Sonnet or GPT-4o) are billed at approximately \$0.10 per request.
• High-reasoning models (such as o1 or extended-thinking Sonnet) with multi-turn agent execution may incur higher pass-through token fees based on actual input and output tokens consumed.

Critical configuration: setting hard spend caps

To prevent unexpected credit card charges from runaway agent loops:

1. Navigate to cursor.com/settings.
2. Under Advanced Settings, locate On-Demand Usage.
3. Set a Hard Limit (e.g., \$20 or \$50). Once accrued on-demand charges hit this exact figure, Cursor immediately stops making paid calls and forces all subsequent requests into the free Slow queue.
4. Set a Soft Limit (e.g., \$10). Cursor will send an email alert when your monthly overage crosses this threshold without interrupting execution.

```
┌─────────────────────────────────────────────────────────────┐
│ Cursor Request Lifecycle Flow │
└──────────────────────────────┬──────────────────────────────┘
│
Developer submits prompt in Chat/Composer
│
Are Fast Requests available? (>0)
├─── YES ───► Route immediately (0 wait)
│
NO
│
Is On-Demand Usage enabled?
├─── YES ───► Within Hard Spend Cap?
│ ├─── YES ───► Fast route (~$0.10 billed)
│ └─── NO ───► Drop to Slow Queue
│
NO
│
Drop to Slow Requests (Free, queued during peaks)
```

The Bring Your Own Key (BYOK) reality check

Many developers consider adding their personal Anthropic or OpenAI API keys into Cursor to bypass the 500-request limit. While supported, this approach has specific technical and financial trade-offs.

What BYOK covers vs what it misses

• Covered: Standard Chat sidebar conversations and Cmd+K inline file edits.
• Not covered: Cursor Tab (predictive auto-complete) and @codebase vector search. These services rely on Cursor’s proprietary infrastructure and cannot be pointed to external API keys. If you cancel your Pro subscription and use BYOK on the Free tier, you lose unlimited Cursor Tab.

Financial trade-off: API pricing vs Cursor Pro

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

• A single Composer prompt with a 40,000-token repository context on Claude 3.7 Sonnet costs roughly \$0.12 in input tokens alone on your personal API key.
• Ten multi-turn debugging prompts can easily cost \$2.00 to \$3.00 via direct API billing.
• In practice, developers who make 500+ heavy agentic requests per month typically spend substantially less on Cursor Pro (\$20 flat) + modest on-demand overages than they would paying raw token bills directly to Anthropic or OpenAI.

Team and Business pooled usage

In organizational deployments, Cursor Business (\$40/seat/mo) changes how quotas behave:

• Pooled Fast Requests: An engineering organization with 20 seats receives a shared pool of 10,000 Fast Requests per month. If junior engineers use 200 requests while senior architects use 800, no individual seat is blocked.
• Centralized spend controls: Team admins can set organization-wide on-demand budget ceilings, preventing individual developers from running up high individual cloud bills.
• Privacy mode enforcement: Business plans allow workspace administrators to enforce zero-retention policies across all developer machines, ensuring proprietary intellectual property is never cached or used for model training.

Practical strategies when limits are reached

When your 500 Fast Requests run out mid-sprint:

1. Assess peak vs off-peak timing: If you are working outside 9 AM – 5 PM US Eastern time, the Slow queue is often virtually instantaneous. Try executing a few test prompts before enabling paid overages.
2. Use cursor-small for simple tasks: Switching model selection to compact models for routine boilerplate, docstrings, and simple syntax fixes conserves your fast compute quota for complex architectural refactoring.
3. Set a reasonable \$20 spend cap: Toggling on-demand billing with a strict \$20 cap provides an additional ~200 fast frontier requests, sufficient to finish intense release weeks without unbounded financial exposure.