# How Cursor Handles Billing: A Complete Breakdown

> A deep dive into Cursor's pricing tiers, token-based usage pools, model-weighted costs, and how to build the same hybrid billing model for your own AI product.
- **Author**: Ayush Agarwal
- **Published**: 2026-04-08
- **Category**: AI, Billing
- **URL**: https://dodopayments.com/blogs/cursor-billing-model

---

Cursor went from a niche VS Code fork to a $9 billion valuation in under two years. A big part of that growth comes from a billing model that most developer tools get wrong: charging for AI usage without making users feel nickel-and-dimed.

Their approach sits at the intersection of [subscription pricing](https://dodopayments.com/blogs/subscription-pricing-models) and [usage-based billing](https://dodopayments.com/blogs/usage-based-pricing-examples), wrapping multiple LLM providers behind a single monthly fee. This post breaks down exactly how Cursor's billing works, what makes it effective, where the friction points are, and how you can build the same model for your own AI product using [Dodo Payments](https://dodopayments.com).

## Cursor's Pricing Tiers

Cursor offers six plans split across individual and business use cases. Pricing is monthly with annual discounts available.

**Individual Plans**

| Plan  | Price   | What You Get                                                                                          |
| :---- | :------ | :---------------------------------------------------------------------------------------------------- |
| Hobby | Free    | Limited Agent requests, limited Tab completions, no credit card required                              |
| Pro   | $20/mo  | $20 API usage included, extended Agent limits, frontier model access, MCPs/skills/hooks, Cloud Agents |
| Pro+  | $60/mo  | $70 API usage included, 3x usage on all OpenAI/Claude/Gemini models                                   |
| Ultra | $200/mo | $400 API usage included, 20x usage on all models, priority access to new features                     |

**Business Plans**

| Plan       | Price       | What You Get                                                                                                        |
| :--------- | :---------- | :------------------------------------------------------------------------------------------------------------------ |
| Teams      | $40/user/mo | Everything in Pro plus shared chats/commands/rules, centralized billing, usage analytics, RBAC, SAML/OIDC SSO       |
| Enterprise | Custom      | Everything in Teams plus pooled usage, invoice/PO billing, SCIM, AI code tracking API, audit logs, priority support |

The jump from Pro to Pro+ is $40/month but gives you $50 more in API usage and 3x multipliers. The Ultra tier at $200/month includes $400 of API credits, meaning Cursor is effectively subsidizing heavy users to keep them on the platform. This is a classic land-and-expand play that many [AI billing platforms](https://dodopayments.com/blogs/ai-billing-platforms) aim to replicate.

## How Cursor's Billing Actually Works

Cursor's billing is more nuanced than a simple "pay $20, get X requests" model. Under the hood, it runs two parallel usage pools, token-based metering, and model-weighted cost calculations.

### Two Usage Pools

Every individual plan includes two separate usage budgets that reset monthly:

- **Auto + Composer Pool**: Covers Cursor's own Composer model and the "Auto" mode where Cursor selects the optimal model for a task. This pool is cheaper per token and designed for everyday coding work.
- **API Pool**: Covers specific model selections (Claude, GPT, Gemini, Grok) at each provider's API pricing. Pro includes $20, Pro+ includes $70, Ultra includes $400.

This dual-pool design lets Cursor steer users toward their own models (which are cheaper to serve) while still giving access to frontier models when users want them. It is a cost management strategy as much as a pricing strategy.

### Token-Based Pricing

Cursor charges based on tokens consumed, not a flat "request" count. Different models have very different per-token rates:

| Model             | Provider  | Input (per 1M tokens) | Output (per 1M tokens) |
| :---------------- | :-------- | :-------------------- | :--------------------- |
| Composer 2        | Cursor    | $0.50                 | $2.50                  |
| GPT-5 Mini        | OpenAI    | $0.25                 | $2.00                  |
| Claude 4.6 Sonnet | Anthropic | $3.00                 | $15.00                 |
| Claude 4.6 Opus   | Anthropic | $5.00                 | $25.00                 |
| Gemini 3.1 Pro    | Google    | $2.00                 | $12.00                 |
| Grok 4.20         | xAI       | $2.00                 | $6.00                  |

A simple chat message using Composer 2 might cost fractions of a cent. An agentic coding session with Claude 4.6 Opus could burn through $5+ in a single complex task. This means the same $20 Pro budget stretches dramatically depending on which models you use.

### Model-Weighted Cost Calculation

The [billing deconstruction on Dodo's docs](https://docs.dodopayments.com/developer-resources/billing-deconstructions/cursor) illustrates this with a credit-cost model. The idea is straightforward: different actions consume different amounts of your budget based on the underlying model's cost.

```mermaid
flowchart LR
    A["User Request"] --> B{"Which Model?"}
    B -->|"Auto/Composer"| C["Auto Pool
$0.50-$6/1M tokens"]
    B -->|"Specific Model"| D["API Pool
Provider rates"]
    C --> E{"Budget Left?"}
    D --> E
    E -->|"Yes"| F["Process Request"]
    E -->|"No"| G{"On-Demand Enabled?"}
    G -->|"Yes"| H["Bill Overage"]
    G -->|"No"| I["Prompt to Upgrade"]
    H --> F
```

This is fundamentally a [credit-based billing](https://docs.dodopayments.com/features/credit-based-billing) approach where the "credits" are denominated in dollars rather than abstract units.

### What Happens at the Limit

When you exhaust your included usage, Cursor gives you two options:

1. **On-demand usage**: Continue at the same API rates with pay-as-you-go billing at the end of the cycle
2. **Upgrade**: Move to a higher tier for more included usage

Notably, Cursor no longer downgrades request quality or speed. Earlier versions routed exhausted users to a "slow queue" with cheaper models. The current system keeps quality consistent and simply charges overages, which is a better experience but puts more emphasis on cost transparency.

### Team and Enterprise Pooling

Business plans add a layer of complexity. The Teams plan at $40/user/month gives each seat its own usage allocation. Enterprise plans go further with pooled usage across the entire organization.

[Seat-based billing](https://dodopayments.com/blogs/pay-per-seat-billing-b2b) combined with shared usage pools is increasingly common in AI tools. It gives admins a predictable per-seat cost while avoiding the problem of power users hitting limits while casual users leave credits on the table.

## What Makes Cursor's Billing Effective

### Provider Abstraction

Users pay one subscription and access models from OpenAI, Anthropic, Google, xAI, and Cursor's own Composer. No separate API keys, no separate billing relationships. This wrapping simplifies the experience and creates real lock-in - once a team's workflow depends on switching between Claude and GPT within the same editor, leaving Cursor means losing that convenience.

### Usage-Dollar Denomination

By denominating usage in dollars rather than abstract "credits" or "fast requests," Cursor makes costs immediately understandable. A developer knows what "$20 of API usage" feels like in a way that "500 premium requests" never communicates clearly. This transparency reduces billing-related churn and support tickets.

> The best billing models make the unit of measurement obvious. When users can't estimate their costs before the invoice arrives, trust erodes fast. Cursor solved this by making the unit a dollar, not a credit.
>
> - Ayush Agarwal, Co-founder & CPTO at Dodo Payments

### Graceful Limit Handling

Instead of hard cutoffs or degraded service, Cursor prompts users to enable on-demand billing or upgrade. The product keeps working at full quality. This approach keeps developers in flow state rather than forcing them to stop coding and manage their billing - a friction point that kills retention in developer tools.

### Tiered Value Scaling

The progression from $20 to $60 to $200 isn't linear. Pro+ gives 3x usage multipliers, Ultra gives 20x. Heavy users get disproportionately better value, which rewards exactly the behavior Cursor wants: deep daily usage that builds switching costs. This is a well-executed version of [flexible billing](https://dodopayments.com/blogs/flexible-billing-platforms) that avoids the [pricing cliffs](https://dodopayments.com/blogs/top-pricing-mistakes-founders-make) common in SaaS.

## Billing Challenges to Watch

### Cost Unpredictability for Users

Token-based pricing is inherently variable. A developer who primarily uses Composer 2 ($0.50/1M input tokens) will have a very different monthly bill than one who defaults to Claude 4.6 Opus ($5/1M input tokens), even with the same number of coding sessions. Without careful usage dashboards and alerts, users can hit overages they didn't anticipate.

This is the core tension in any [usage-based pricing](https://dodopayments.com/blogs/implement-usage-based-billing) model: fairness and cost alignment come at the expense of predictability. Cursor mitigates this with usage dashboards, but the problem persists for teams without strict governance.

### Model Menu Complexity

Cursor's model pricing page lists 30+ models with different per-token rates, cache pricing, and context window surcharges. Some models require "Max Mode" which adds a 20% upcharge. Others have 2x pricing when input exceeds 200K tokens. This complexity is necessary given the multi-provider reality, but it creates cognitive overhead for users trying to optimize their spend.

### Enterprise Billing Friction

The jump from self-serve Teams ($40/user/month) to Enterprise (custom pricing, sales-led) is a gap that affects mid-market companies. A 50-person team paying $2,000/month self-serve might need pooled usage and invoicing but not the full Enterprise package. This is a common [billing automation](https://dodopayments.com/blogs/billing-automation-saas) challenge where the pricing structure doesn't cleanly map to customer segments.

### Margin Pressure from Provider Costs

Cursor is reselling API access from OpenAI, Anthropic, and Google at or near cost. The included usage on Pro ($20 API credits for a $20/month subscription) suggests margins on the base tier are thin, with profitability coming from users who don't exhaust their allocation and from higher tiers where the ratio improves. If upstream provider pricing shifts, Cursor's margins can change overnight.

## How to Build a Similar Billing Model with Dodo Payments

If you're building an AI coding tool, GPT wrapper, or any product that needs [subscription plus usage-based billing](https://dodopayments.com/blogs/subscriptions-usage-based-billing-saas), here's how to replicate Cursor's model with [Dodo Payments](https://dodopayments.com).

The full implementation is documented in the [Cursor billing deconstruction](https://docs.dodopayments.com/developer-resources/billing-deconstructions/cursor) on Dodo's docs. Below are the key building blocks.

### Step 1: Define Credit Entitlements

Create a custom unit credit entitlement in the Dodo dashboard that represents your usage pool. Set the unit name to something like "API Credits," configure a 30-day expiry with no rollover, and enable overages at your chosen per-unit price.

This maps directly to Cursor's model: each tier gets a different number of credits, credits reset monthly, and users can pay for overages when they run out. Dodo's [credit-based billing](https://docs.dodopayments.com/features/credit-based-billing) handles all of this natively.

### Step 2: Create Subscription Products

Create a product for each tier and attach the credit entitlement with different allocations:

```typescript
import DodoPayments from "dodopayments";

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

// Create a subscription for a user on the Pro tier
const subscription = await client.subscriptions.create({
  billing: {
    city: "San Francisco",
    country: "US",
    state: "CA",
    street: "123 Market St",
    zipcode: 94105,
  },
  customer: {
    email: "developer@example.com",
    name: "Jane Developer",
  },
  product_id: "pdt_pro_plan", // Your Pro plan product ID
  quantity: 1,
});
```

This creates a [recurring subscription](https://docs.dodopayments.com/features/subscription) that automatically allocates credits and handles renewals. No manual credit management needed.

### Step 3: Track Usage with Weighted Metering

This is where Cursor's model gets interesting. Different models cost different amounts, so your usage events need to carry a weight. Create a meter with **Sum** aggregation on a `credit_cost` property:

```typescript
import DodoPayments from "dodopayments";

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
});

// Define model costs in your application
const MODEL_COSTS: Record<string, number> = {
  "composer-2": 1,
  "gpt-5-mini": 1,
  "claude-4.6-sonnet": 5,
  "claude-4.6-opus": 10,
  "gemini-3.1-pro": 4,
};

// Track each AI request as a usage event
async function trackAIRequest(
  customerId: string,
  model: string,
  requestType: string,
) {
  const creditCost = MODEL_COSTS[model] ?? 1;

  await client.usageEvents.ingest({
    events: [
      {
        event_id: `req_${Date.now()}_${Math.random().toString(36).slice(2)}`,
        customer_id: customerId,
        event_name: "ai.request",
        timestamp: new Date().toISOString(),
        metadata: {
          model,
          request_type: requestType,
          credit_cost: creditCost,
        },
      },
    ],
  });
}

// Example: User runs an agent task with Claude 4.6 Sonnet
await trackAIRequest("cus_abc123", "claude-4.6-sonnet", "agent");
```

The meter sums the `credit_cost` values and deducts from the user's credit balance automatically. When credits run out, Dodo fires a webhook so you can handle degradation or overage billing. This is the same [event ingestion](https://docs.dodopayments.com/features/usage-based-billing/introduction) pattern used for API metering, token tracking, and any consumption-based model.

### Step 4: Handle Credit Exhaustion via Webhooks

Listen for credit balance changes to implement your limit handling logic - whether that is routing to cheaper models, enabling overages, or prompting an upgrade:

```typescript
import DodoPayments from "dodopayments";
import express from "express";

const app = express();
app.use(express.raw({ type: "application/json" }));

const client = new DodoPayments({
  bearerToken: process.env.DODO_PAYMENTS_API_KEY,
  webhookKey: process.env.DODO_PAYMENTS_WEBHOOK_KEY,
});

app.post("/webhooks/dodo", async (req, res) => {
  const event = client.webhooks.unwrap(req.body.toString(), {
    headers: {
      "webhook-id": req.headers["webhook-id"] as string,
      "webhook-signature": req.headers["webhook-signature"] as string,
      "webhook-timestamp": req.headers["webhook-timestamp"] as string,
    },
  });

  if (event.type === "credit.balance_low") {
    const customerId = event.data.customer_id;

    // Option 1: Route to cheaper models (Cursor's old "slow queue")
    await setUserModelTier(customerId, "basic");

    // Option 2: Notify user and let them choose
    await sendUsageAlert(customerId, {
      message: "You have used most of your included credits.",
      remaining: event.data.remaining_credits,
      options: ["enable_overages", "upgrade_plan"],
    });
  }

  res.json({ received: true });
});
```

Dodo's [webhook system](https://docs.dodopayments.com/developer-resources/webhooks) delivers these events in real-time, so your application can react instantly rather than discovering the overage at the end of the billing cycle.

### Step 5: Team Pooling for Business Plans

For team billing, create a single organization-level customer in Dodo and track all team members' usage against that shared pool. Combine this with per-seat add-ons for the platform fee:

```typescript
// All team members' usage goes to the org customer
await trackAIRequest("org_acme_corp", "claude-4.6-sonnet", "agent");

// The org subscription handles seat-based pricing + pooled credits
// Individual user_id is tracked in metadata for internal analytics
```

This gives you the same model Cursor uses for Enterprise: predictable per-seat revenue with shared credit pools that absorb usage variance across the team.

## Cursor's Billing Model in Context

Cursor's approach represents a broader shift in how AI-native products handle billing. The old SaaS playbook of [flat-rate tiers](https://dodopayments.com/blogs/one-time-vs-subscription-saas-pricing) breaks down when your marginal cost varies by 50x depending on which model a user selects.

The hybrid model - subscription base plus usage-weighted credits - is becoming the standard for AI tools. It gives users predictability (a known monthly fee), flexibility (choice of models), and fairness (costs scale with actual consumption). If you are building in this space, the key is picking billing infrastructure that supports [credits, metering, and subscriptions](https://dodopayments.com/blogs/billing-credits-pricing-cashflow) as first-class primitives rather than bolting usage tracking onto a traditional subscription system.

For a full walkthrough of the implementation with code examples, credit entitlements, and webhook handling, see the [Cursor billing deconstruction](https://docs.dodopayments.com/developer-resources/billing-deconstructions/cursor) in Dodo's documentation.

## FAQ

### How does Cursor's pricing compare to other AI coding tools?

Cursor's Pro plan at $20/month is competitive with GitHub Copilot ($10-$19/month) and similar tools. The key difference is Cursor's multi-model access and token-based pricing. Most competitors offer flat request limits, while Cursor gives you a dollar-denominated budget you can spend across any supported model. The Pro+ ($60/month) and Ultra ($200/month) tiers target power users with no equivalent in most competing tools.

### Can you use Cursor for free?

Yes. Cursor's Hobby tier is free with no credit card required. It includes limited Agent requests and limited Tab completions. The free tier is designed as a trial experience. Most active developers will hit the limits within a few days of regular use, making it effectively a [freemium conversion funnel](https://dodopayments.com/blogs/saas-free-trial-vs-freemium) rather than a sustainable free plan.

### What happens when you run out of Cursor credits?

When your included API usage is exhausted, Cursor prompts you to either enable on-demand usage (pay-as-you-go at the same per-token rates, billed at the end of the cycle) or upgrade to a higher tier. Requests are never downgraded in quality or speed. If you do nothing, you simply cannot make new requests until the next billing cycle resets your allocation.

### Is Cursor's billing model usage-based or subscription-based?

It is both. Cursor uses a hybrid model where users pay a fixed monthly subscription that includes a set amount of usage. This combines the predictability of [subscription billing](https://dodopayments.com/blogs/best-subscription-billing-software) with the fairness of [metered pricing](https://dodopayments.com/blogs/metered-pricing-guide). The subscription covers a usage floor, and on-demand billing handles anything above that.

### How can I build a billing model like Cursor's for my own AI product?

You need three components: subscription management for recurring plans, credit entitlements for usage pools, and event ingestion for tracking consumption. [Dodo Payments](https://dodopayments.com) supports all three natively. The [Cursor billing deconstruction](https://docs.dodopayments.com/developer-resources/billing-deconstructions/cursor) provides a step-by-step implementation guide with code examples for creating the subscription, metering AI requests with weighted costs, and handling credit exhaustion via webhooks.

## Final Take

Cursor's billing model works because it solves the fundamental tension in AI product pricing: variable infrastructure costs versus user demand for predictable bills. The dual-pool system, dollar-denominated usage, and graceful limit handling create an experience where users feel in control of their spending while Cursor maintains healthy margins on most accounts.

If you are building an AI product with similar cost dynamics - multiple models, variable per-request costs, both individual and team use cases - the same architecture applies. Start with a [subscription base](https://dodopayments.com/blogs/set-up-subscription-billing-afternoon), layer on [credit-based metering](https://dodopayments.com/blogs/add-credits-billing-ai-app), and use webhooks to handle the transitions. The billing infrastructure should adapt to your pricing model, not the other way around.

Check out [Dodo Payments](https://dodopayments.com) to build this for your product, or explore the [pricing page](https://dodopayments.com/pricing) to see the rates.
---
- [More AI articles](https://dodopayments.com/blogs/category/ai)
- [All articles](https://dodopayments.com/blogs)