How Much Does Cursor Cost a Team? Seat vs Usage Pricing, Worked Out for 10 and 50 Engineers (2026)
Cursor Teams seats start at $30 per user per month, but Claude and GPT usage is billed on top at API list prices plus a $0.25 per million token Cursor Token Rate. How the weekly pool drains, how overage bills, and a worked budget for 10- and 50-engineer teams.
TL;DR
A Cursor Teams seat costs $30 to $200 per user per month, and for most engineering teams the seat is the smaller part of the bill. Under Cursor's current Teams pricing, each seat buys a weekly pool of Cursor's own models. Claude, GPT and Gemini sit outside that pool and bill from the first request at API list price plus a $0.25 per million token Cursor Token Rate. On a cache-heavy Claude Opus 5.5 agent turn, that rate adds about 64% to the list cost. Our worked budget puts a 10-engineer team at roughly $1,530–4,400 a month and a 50-engineer team at roughly $7,650–22,000, depending almost entirely on model mix. Cursor does not publish a per-developer average, so the assumptions are written out below for you to replace.
If your notes say "$40 a seat," they are describing the old plan. Cursor rebuilt its pricing around The X Subscription on October 12, 2026, and the $40 Standard seat is now legacy.
What a Cursor team seat buys in 2026
Cursor's Teams pricing doc lists four seat types for teams on the new pricing, which can be mixed on one team:
| Seat | Price | Weekly Cursor-model pool | Third-party models |
|---|---|---|---|
| Free | $0/user/month | None ("no team usage allowance") | Not included |
| Premium | $30/user/month | Baseline | API list price + Token Rate, from the first request |
| Super | $100/user/month | 3.75x Premium | Same |
| Ultra | $200/user/month | 12.5x Premium | Same |
| Enterprise | Custom (pricing) | Pooled across all users | Same, with group-level spend limits |
Three details change how you budget.
The pool is per seat and weekly. "Seats don't share weekly pools with each other," per the doc, and usage "doesn't transfer between team members." An engineer who barely touches Cursor this week does not subsidise the one who burns through their pool on Tuesday. Pooling across the team is reserved for Enterprise.
The pool covers only Cursor's models. That means Grok 4.7, 4.6, 4.5 and Composer 2.5. "Third-party models aren't included," so every Claude or GPT request is metered in dollars from the first token.
Annual Teams pricing is not published. Individual plans list annual prices (Premium is $300 a year), but the pricing doc gives Teams only as a monthly per-seat price. Ask sales before you assume a discount.
Teams created before the change keep their legacy Standard ($40/user/month) and Premium ($120/user/month) seats, with two monthly pools and on-demand billing in arrears. The rest of this post uses the new pricing.
How the included pool drains
The pool is denominated in usage, not dollars, and Cursor's docs say only that "different models draw from the pool at different rates" without publishing the multipliers. What is published is the token price each Cursor model bills at once the pool is gone, per million tokens (source):
| Cursor model | Input | Cache read | Output |
|---|---|---|---|
| Composer 2.5 | $0.50 | $0.20 | $2.50 |
| Grok 4.7 | $2 | $0.50 | $6 |
| Grok 4.7 (Fast) | $4 | $1 | $12 |
| Composer 2.5 (Fast) | $3 | $0.50 | $15 |
Read that table as a drain rate. A Fast variant costs six times the standard Composer 2.5 on output, so an engineer who leaves Fast on will empty a weekly pool faster than one who doesn't. Grok 4.7 also bills at 2x once input passes 256k tokens, so long context drains it faster again.
Once the pool is empty, Cursor-model usage keeps going at those token rates, paid from the team's prepaid balance, with no Token Rate added. It stops when the balance is empty or when the team hits its monthly additional-usage limit.
How third-party usage and overage bill
Claude and GPT usage never touches the pool. It is paid from a prepaid balance that the whole team shares, at the model's list price plus the Cursor Token Rate. Relevant list prices from Cursor's model table, matching Anthropic's own pricing page, per million tokens:
| Model | Input | 5-min cache write | Cache read | Output |
|---|---|---|---|---|
| Claude Opus 5.5 | $4 | $5 | $0.20 | $20 |
| Claude Sonnet 5.5 | $2 | $2.50 | $0.10 | $10 |
| GPT-5.5 | $5 | not listed | $0.50 | $30 |
The Token Rate, per Cursor's pricing doc, "applies to input, output, and cached tokens." It does not apply to Cursor models, to Auto's Cost mode, or to a short list of excluded small models such as Claude Haiku 5.5. Individual plans don't pay it at all.
That last clause about cached tokens is where team budgets go wrong. Take one agent turn in a session carrying 150,000 tokens of cached context, with 2,000 new input tokens and 1,000 output tokens, on Claude Opus 5.5:
- Cache read: 150,000 × $0.20/M = $0.030
- New input written to cache: 2,000 × $5/M = $0.010
- Output: 1,000 × $20/M = $0.020
- List cost: $0.060
- Token Rate: 153,000 × $0.25/M = $0.038, about 64% on top
On Claude Sonnet 5.5 the same turn lists at $0.030 and the Token Rate is still $0.038, so the surcharge is larger than the model cost. Caching is supposed to make long sessions cheap. Under a flat per-token surcharge, it makes them cheap only on the provider's side of the bill.
Routing adds one more path. On Teams with Cursor Router, the Balance and Intelligence Auto modes "bill at the routed model's list price": a route to a Cursor model uses the pool, a route to Claude or GPT is paid from prepaid credit. The same prompt can land on either ledger depending on what the router picks.
A worked budget for 10 and 50 engineers
Cursor publishes no per-developer usage average, so this budget borrows the nearest published figure: Anthropic's $150–250 per developer per month for daily Claude Code use at API rates. Treat it as an assumption, not a Cursor number.
Assumptions, stated so you can swap in your own:
- Every engineer holds a Premium seat ($30).
- Engineers who use third-party models run Claude Opus 5.5 at $150–250 a month of API-list usage.
- Their mix looks like the cache-heavy turn above, so the Token Rate adds about 64%.
- Engineers on Cursor models stay inside their weekly pool.
- Monthly list prices, no negotiated discount.
| 10 engineers | 50 engineers | |
|---|---|---|
| Premium seats ($30 × headcount) | $300 | $1,500 |
| Half the team on Opus 5.5: API-list usage | $750–1,250 | $3,750–6,250 |
| Token Rate (~64%) | $480–800 | $2,400–4,000 |
| Total, half on third-party | $1,530–2,350 / month | $7,650–11,750 / month |
| Whole team on Opus 5.5: API-list usage | $1,500–2,500 | $7,500–12,500 |
| Token Rate (~64%) | $960–1,600 | $4,800–8,000 |
| Total, all on third-party | $2,760–4,400 / month | $13,800–22,000 / month |
Two things follow from the arithmetic. First, the seat line is 7–20% of the total in every scenario that uses Claude, so arguing about Premium versus Super seats is the wrong fight unless your team lives on Cursor's own models. Second, the Token Rate row is sensitive to caching. An output-heavy mix pays proportionally less of it; a mix of long agent sessions that re-read a large cached context every turn pays more. Your own ratio is something you can only get from event-level data.
Where Cursor spend actually goes
Most of a long agent session's tokens are the context it carries, not what it writes. That makes the same habits expensive in Cursor that are expensive elsewhere, with the Token Rate stacked on top:
- Context carry: A session that is never restarted between unrelated tasks re-sends its whole history every turn. Each of those cached tokens costs $0.25 per million on top of list. See context efficiency.
- Model defaults: Leaving a frontier third-party model, or a Fast variant, as the default for routine edits multiplies everything. GPT-5.5 also doubles input pricing on long context.
- Router drift: With Balance or Intelligence on, spend moves between the pool and the prepaid balance without anyone choosing it.
- Unused seats: Weekly pools do not roll over or transfer, so a Super seat held by a light user is paid-for capacity nobody draws on.
Spend you can remove without removing any of the work is what we call recoverable token waste.
How to get an honest number for your team
- Set the guardrails first. Teams get one monthly additional-usage limit plus a default per-member limit with overrides. When the team limit is reached, "paid additional usage pauses until next month," even with prepaid credit left. Enterprise adds group-level limits.
- Pull the event data. The Admin API returns per-member spend and usage events with model, tokens and
chargedCents. No per-repo breakdown is documented, and workflow-level cost is limited to automations and cloud agent runs. - Price everything at API rates. Seats, pool usage and prepaid usage only add up, and only compare with Claude Code or Codex, when they share a unit. Attributing spend per developer covers the method.
- Watch the trend. Cursor's pricing changed structurally in October and its docs flag promotional rates (GPT-5.6 Sol through November 21, 2026). A budget set in September is already stale.
Promptster Teams gives you the real number
Promptster Teams attributes AI coding spend across Claude Code, Codex and Cursor by repo and workflow, priced at API rates so seats and usage bills land on one ledger. Each engineer sees their own figures; managers see team and squad totals, never a per-person ranking. It separates recoverable waste from spend that shipped work, and code and diffs are redacted on the engineer's machine before upload. It is not developer monitoring.
If your answer to "how much does Cursor cost us?" is the seat count times $30, the Token Rate alone says that number is low.
See how Promptster Teams attributes AI coding spend →
Related: How much does Claude Code cost a team? · How much does Codex cost a team? · Claude Code vs Codex vs Cursor cost · Claude Team vs Enterprise vs API · What a $100 AI coding plan is worth · What is TokenOps? · TokenOps metrics
Frequently asked questions
How much does Cursor cost per developer on a team?
The seat is $30, $100 or $200 per user per month on Cursor's current Teams pricing (Premium, Super, Ultra). Each seat includes a weekly pool for Cursor's own models (Grok and Composer). Claude, GPT and Gemini are not in that pool: they bill from the first request at the model's API list price plus a Cursor Token Rate of $0.25 per million tokens. So the seat is a floor, and what a developer costs depends mostly on how much third-party model usage they run.What does Cursor cost for a team of 50 engineers?
Fifty Premium seats are $1,500 a month. Cursor does not publish a typical per-developer usage figure, so the rest depends on your model mix. Under the assumptions in this post (half the team running Claude Opus 5.5 at $150–250 a month of API-list usage, with a cache-heavy agent mix), the team lands around $7,650–11,750 a month; with everyone on third-party models, around $13,800–22,000.What is the Cursor Token Rate?
A charge of $0.25 per million tokens that Cursor adds on top of API list prices for eligible third-party model requests on Teams and Enterprise. It applies to input, output and cached tokens, and it does not apply to Cursor's own models or a list of excluded small models. Because cached tokens are cheap at list price but still carry the full $0.25, the Token Rate is a large share of the bill on long, cache-heavy agent sessions.Is Cursor Teams usage pooled across the team?
Not on Teams. Cursor's docs say seats do not share weekly pools and usage does not transfer between members; only the prepaid balance for additional usage is shared. Pooled usage across all users is an Enterprise feature, and Enterprise pricing is custom.Can I see Cursor spend per developer or per repo?
Per developer, yes: Cursor's Admin API returns per-member spend and event-level usage with the model, tokens and charged cents. Per repo, no breakdown is documented, and per-workflow attribution is limited to automations and cloud agent runs. Knowing which repo or habit produced the spend needs a separate attribution layer.