Cursor On-Demand Usage: Pricing, Hard Limits, and Cost Control

A software engineer orchestrating an autonomous refactoring loop across a large repository can exhaust an entire monthly model allowance in an afternoon, triggering unexpected overage charges if usage-based billing is active without guardrails. The friction is not the speed of upstream inference; it is the silent accumulation of post-paid API charges when multi-file prompts inflate token payloads. Cursor on-demand usage is an opt-in billing setting that allows Pro and Business users to continue making fast API model requests after depleting their included monthly quota at per-request pricing with configurable spend limits.

Cursor separates model consumption into two distinct pools that reset at the start of each billing cycle:

• Cursor Models Pool: Covers first-party models optimized for code editing, including Grok 4.7, Grok 4.6, Grok 4.5, and Composer 2.5. Subscriptions provide substantial allowances for this pool, making it the primary engine for continuous inline completions and rapid code transformation.
• Other Models Pool: Covers third-party frontier models, including Claude Sonnet 5.5, Claude Opus 5.5, Claude Haiku 5.5, Claude Fable 5.1, GPT-5.6 Sol, GPT-5.6 Terra, GPT-5.6 Luna, Gemini 3.1 Pro, Gemini 3.8 Flash, and Muse Spark 1.3. Requests routed to these models are billed against your subscription allowance at the provider's published API rates.

On individual subscription plans, Cursor Pro is priced at $20/mo, Pro Plus at $60/mo, and Ultra at $200/mo. Each plan tier includes a baseline credit pool that absorbs a designated volume of frontier model interactions. When developers exceed their included pool balance, Cursor switches to on-demand usage if the account has enabled usage-based billing.

For organizations running multi-seat deployments, Cursor provides Teams plans with Standard and Premium tier seats alongside custom Enterprise agreements. On Teams and Enterprise plans, third-party model requests include a Cursor Token Rate of $0.25 per million tokens. This rate applies on top of model API pricing for included usage, on-demand usage, and bring-your-own-key usage. First-party Cursor models, such as Grok and Composer, remain exempt from this token surcharge.

Monitoring these pools in real time allows engineering teams to identify whether credit depletion stems from frequent routine prompts or heavy architectural queries sent to costly frontier models.

• Claude Code Pricing: Plans, Costs, and Usage Limits ExplainedAnthropic doubled Claude Code's five-hour usage caps in May 2026, but most pricing guides still lump chat and coding...
• Devin AI Credits: On-Demand Pricing, Rollover Rules, and Usage QuotasDevin on-demand credits are prepaid usage credits that fund tasks exceeding included plan quotas, power team...
• Cursor Rate Limits Explained: Fast Requests, Concurrency, and API KeysCursor rate limits control how quickly and frequently developers can submit AI queries during coding sessions. While...
• Cursor Agent Mode: Managing Autonomous Edits in Shared WorkspacesCursor Agent mode enables developers to automate complex multi-file refactors and terminal executions directly from the...
• Cursor Cycle Agent Count: Managing Parallel Agents and Token BudgetsCursor cycle agent count is a concurrency setting in Cursor IDE that spawns multiple parallel AI subagents to...
• How to Connect Cursor to Cloud Workspaces with Filesystem MCPCursor Filesystem MCP connects Cursor's AI Composer and Agent mode to file trees and cloud repositories through Model...

More on this subject: AI Coding Assistants (78 guides)

On-demand pricing in Cursor operates without artificial markup on individual plans. Once your included allowance is depleted, subsequent requests draw compute at the direct per-token rate of the chosen model. However, because modern coding assistants process both input context and output generations, the actual cost of a single prompt varies based on prompt size, caching efficiency, and reasoning depth.

The following pricing reference outlines token rates per million tokens across supported models, reflecting published developer pricing:

How Context and Caching Dictate On-Demand Cost

The rates listed above explain why seemingly brief interactions can generate disparate invoice amounts. Prompt construction follows specific operational mechanics:

1. Input Token Volume: When you reference multiple project files in Composer, Cursor bundles the full text of those files into the input payload. An interaction referencing thirty TypeScript files can transmit tens of thousands of input tokens before you write a single line of instruction.
2. Prompt Caching Discounts: Upstream providers offer substantial discounts when consecutive requests reuse identical prompt prefixes. For example, Claude Sonnet 5.5 significantly discounts cached reads compared to initial input writes. If your workflow makes small modifications while keeping context stable, caching protects your budget. If you continuously add and remove files, cache invalidation forces full input billing on every turn.
3. Output Generation Multipliers: Generating verbose code explanations, full file rewrites, or expanded unit test suites costs substantially more per token than reading input. On premium reasoning models like Claude Opus 5.5 or GPT-5.6 Sol, output tokens cost multiple times more than input tokens, making lengthy generative responses an immediate driver of overage.

Cursor Router and Automated Model Selection

Cursor Router introduces an automated abstraction over model selection through Auto mode. Auto mode offers three operating profiles: Cost, Balance, and Intelligence. In Cost mode, the router routes requests to lightweight models like Composer 2.5 or Gemini 3.8 Flash whenever possible. In Intelligence mode, complex reasoning tasks route to frontier models like Claude Sonnet 5.5 or GPT-5.6 Sol.

Because Auto requests are billed at the list price of the routed model, background agent turns can draw from either the Cursor Models pool or the Other Models pool. Subagents launched by the primary agent may also invoke specific frontier models independently, incurring on-demand charges if your included pool is exhausted.

To protect subscribers from runaway charges during intensive development sprints, Cursor defaults to a configurable spend limit in account preferences. By setting an explicit monetary threshold, developers ensure that automated background agents and multi-file Composer runs halt before generating surprise invoices.

Step-by-Step Spend Limit Configuration

Configuring spending caps requires direct adjustment within your account portal:

1. Access the Billing Portal: Navigate to cursor.com/dashboard (or cursor.com/settings) in your browser and select the Spending tab.
2. Review Pool Utilization: Inspect the real-time consumption gauges for both the Cursor Models pool and the Other Models pool to see your remaining monthly allowances.
3. Set Monthly Spend Limit: Locate the Monthly Limit dropdown menu. Choose an explicit dollar threshold that aligns with your monthly development budget, or select custom values according to your expected workload.
4. Disable On-Demand Usage: If you want a strict guarantee against post-paid charges, select Disabled from the dropdown menu. With on-demand disabled, your account will never incur usage-based billing beyond your base subscription fee.
5. Enforce Administrative Governance: In team environments, team managers can navigate to the Permissions section and enable the toggle labeled Only Admins Can Edit Usage Settings. This prevents team members from independently raising spending limits on company cards.

What Happens When Quotas Are Depleted

When your included usage pool reaches zero, Cursor behaves according to your configured spending preferences:

• When On-Demand Is Disabled: The editor displays an in-app notification indicating that your included quota is exhausted. On legacy subscription configurations, prompts drop into an unprioritized slow queue where requests process when backend cluster capacity is available. On modern usage-based plans, further requests to depleted pools pause until your monthly billing cycle resets or until you manually raise the spend limit.
• When On-Demand Is Enabled: Requests continue executing at top priority without queue delays or latency penalties. Cursor records the exact token consumption of each request and bills the balance to your registered payment card in arrears at the conclusion of your billing cycle.

Understanding Billing Enforcement and Reconciliation

Spend limit enforcement operates with a deliberate architectural tolerance. Because coding agents often execute multi-step tool calls, such as writing a file, checking lint output, and running a test suite, Cursor does not terminate an active prompt mid-stream the microsecond a budget limit is touched. Truncating an in-flight token stream could corrupt a local file or leave git branches in an unrecoverable state.

Consequently, total monthly usage may temporarily register a minor overage above your hard cap. When this happens, Cursor reconciles the difference during invoice generation, issuing a billing adjustment or credit so that your final card charge matches your specified hard limit.

The primary driver of unexpected on-demand charges is rarely how many questions a developer asks; it is how much context each prompt carries. Modern code editors make it trivial to summon entire directory trees using @Files, @Folders, and @Codebase. While providing broad context helps the model understand system architecture, it levies a severe token tax on every interaction.

Every AI platform encounters physical context boundaries. Anthropic documents that Claude chat conversations accept up to 20 files at up to 500MB each, while Claude Projects allow files up to 30MB with unlimited count until constrained by the model context window. Claude Projects has no fixed file-count cap, so any fixed project file count is false; the practical ceiling is the context window itself. In Cursor, the constraint is financial: every additional file injected into Composer inflates the token payload sent upstream, accelerating credit burn and pushing teams into usage-based billing.

The Multi-Turn Compounding Snowball

In agentic workflows, context overhead compounds across conversational turns. Unless explicitly cleared, Cursor resends the cumulative conversation history, including previous user prompts, assistant replies, tool execution traces, and modified code blocks, on every subsequent turn.

Consider the arithmetic of a five-turn debugging session on a complex microservice:

• Turn 1: The developer attaches five core service files and states the problem (35,000 input tokens).
• Turn 2: The assistant requests terminal output from a failed test suite, appending error logs (48,000 input tokens).
• Turn 3: The assistant edits an interface file, adding tool execution diffs (62,000 input tokens).
• Turn 4: A secondary type error appears in an adjacent module, adding new code (85,000 input tokens).
• Turn 5: The developer requests a final unit test, resending the entire conversation transcript (105,000 input tokens).

In this single five-turn troubleshooting session, the developer consumed 335,000 input tokens. Repeating this workflow three times a day across a sprint will deplete a base frontier model allowance within days, forcing the developer into on-demand billing or halting work.

Why Local File Exclusion Rules Are Insufficient

Developers frequently attempt to solve token bloat by configuring local .cursorignore files. A well-maintained ignore file successfully prevents local semantic search from indexing build output, bundled JavaScript, and minified assets:

node_modules/
dist/
build/
.next/
coverage/
*.log
*.sql
*.csv
package-lock.json
pnpm-lock.yaml
yarn.lock
.git/

While .cursorignore keeps local search indices clean, it cannot resolve the broader architectural challenge: engineering teams routinely need access to external technical documentation, API specifications, compliance standards, and shared design systems that live outside the active git repository. Pasting large API schemas or database dictionaries directly into editor chat introduces massive context bloat that burns on-demand credits rapidly.

Control Cursor token spend by offloading codebase context

Connect Cursor to Fast.io workspaces over remote MCP to search extensive repositories and technical documentation without inflating prompt tokens. Monthly plans start with a 14-day free trial, which requires a credit card.

Start 14-Day Trial

Rather than pasting large API contracts, architectural decision records, and company documentation directly into Cursor Composer, engineering teams can offload static reference assets to external cloud workspaces. By connecting Cursor to an external workspace over the Model Context Protocol (MCP), the assistant queries indexed documentation on demand, retrieving only the exact paragraphs required to complete a task.

The Model Context Protocol establishes a standardized, client-agnostic communication standard for AI coding tools. Instead of forcing developers to clone secondary repositories or saturate editor context with raw text files, Cursor can search an external workspace over Streamable HTTP, injecting a 400-token excerpt rather than a 50,000-token file tree.

Fast.io as an External Knowledge Substrate

Fast.io provides cloud workspaces built specifically for agentic teams and multi-agent developer workflows. When engineering teams deposit technical documentation, API contracts, design tokens, and compliance specifications into a Fast.io workspace, enabling Intelligence Mode automatically indexes the files for hybrid search combining full-text, semantic, and metadata-value retrieval.

Cursor connects directly to Fast.io using its dedicated coding agent MCP endpoint over Streamable HTTP at https://mcp.fast.io/mcp/code. Developers configure the connection in their user configuration file at ~/.cursor/mcp.json or within a repository at .cursor/mcp.json:

{
  "mcpServers": {
    "fast-io": {
      "url": "https://mcp.fast.io/mcp/code"
    }
  }
}

Interactive coding clients like Cursor authenticate using standard OAuth in the browser, requiring no static API keys or manual token management in configuration files. Complete setup instructions and client guides are available at Fast.io MCP Documentation.

Once connected, Cursor Composer searches your Fast.io workspaces dynamically. When an engineer instructs Cursor to build a service adhering to the organization's authentication standards, Cursor issues an MCP search query, extracts the specific security requirements, and generates the implementation without loading entire security manuals into prompt context. Review our guide to storage for agents for additional architectural patterns.

Collaborative Capabilities for Engineering Workspaces

Placing technical assets in Fast.io provides infrastructure controls that local file attachments cannot supply:

• Org-Owned Shared Workspaces: Engineering specifications and architectural records remain centralized in shared organizational workspaces where human developers and AI coding agents collaborate on identical source files.
• Per-File Version History: Every document and configuration artifact preserves a full version history, allowing teams to audit modifications made by autonomous coding loops and restore earlier file states at any time.
• Detailed Activity Log: Workspaces maintain a detailed activity log recording every file upload, edit, move, and deletion performed by team members and connected agents.
• Structured Data with Metadata Views: With Metadata Views, engineering teams extract structured fields from technical documentation, generating queryable tables of endpoints, status codes, and payload schemas without writing manual extraction parsers.
• Multi-Cloud Content Synchronization: Fast.io supports Cloud Sync for Google Drive, Dropbox, Box, and OneDrive on a schedule or on demand. This allows teams to aggregate scattered engineering documents into an indexed workspace without manual file transfers.
• Integrated Document Execution: When technical statements of work or partner agreements require formal sign-off, Fast.io provides integrated e-signature on every plan, featuring sequential or parallel signers, optional one-time passcodes, and tamper-evident audit certificates filed directly back into the workspace.

Monthly plans start with a 14-day free trial, which requires a credit card. Review Fast.io pricing for plan tiers: Starter at $9.99/mo (3 seats, 250 GB storage, 5 workspaces, 100,000 credits a month), Business at $49.99/mo (10 seats, 5 TB storage, 50 workspaces, 600,000 credits a month), and Enterprise at $199.99/mo (30 seats included, additional seats at $1 each up to 200, 25 TB storage, 200 workspaces, 3,000,000 credits a month). Extra credits are available at $10 per 100,000 credits, giving engineering teams scalable indexing capacity without token rate markups.

Controlling AI code editor expenditure requires balancing developer velocity with disciplined context hygiene. Implementing systematic prompt and session habits enables engineering teams to preserve included subscription allowances and minimize unnecessary on-demand charges.

1. Reference Exact Symbols Rather than Broad Folders

Avoid using broad folder inclusions for standard development tasks. While pointing to @Folders or invoking @Codebase is helpful when mapping unfamiliar architectures, routine bug fixes rarely require scanning hundreds of peripheral source files.

Adopt targeted referencing patterns:

• Point directly to relevant files using @file:path/to/service.ts.
• Target specific interfaces or classes using @symbol:ClassName.
• Select specific code lines in your active editor tab before invoking inline edits (Cmd+K or Ctrl+K), restricting prompt context to the selected snippet.

2. Prune Long-Running Agent Threads

Extended conversation threads are the largest single contributor to token inflation in Cursor Composer. As an agent session progresses, every previous command, file view, and syntax correction remains in context.

Establish thread termination routines:

• Terminate a chat or Composer thread as soon as a discrete task, bug fix, or function implementation passes verification.
• Never maintain a single continuous conversation across multiple days or distinct Jira tickets.
• When initiating a follow-up task that depends on previous work, write a two-sentence summary of the previous outcome in a fresh session rather than forcing the model to re-ingest dozens of historical turns.

3. Match Model Power to Task Complexity

Frontier reasoning models like Claude Opus 5.5 and GPT-5.6 Sol represent exceptional cognitive tools, but using them for boilerplate tasks burns budgets rapidly. Generating unit test fixtures, drafting docstrings, formatting mock JSON payloads, and writing simple type definitions can be executed with equal fidelity by Composer 2.5 or lighter models.

Reserve expensive frontier models for complex architectural challenges:

• Designing microservice architectures and distributed database schemas.
• Resolving complex asynchronous state bugs and concurrency bottlenecks.
• Large-scale multi-file refactoring that modifies shared API contracts across client-server boundaries.

By routing routine generation to cost-effective models and offloading heavy documentation context to external MCP workspaces, engineering teams maintain peak programming velocity while keeping monthly on-demand costs strictly within budget.