Engineering
Cursor Cost per Developer: Plans, Pricing, Per-Developer Tracking
Find out what Cursor costs per developer in 2026 across individual, Teams and Enterprise plans, what drives the bill, and how to track spend with Nautili.

TL;DR
- Cursor costs $0 to $200 per developer per month on individual plans and $30, $100, or $200 per seat on Teams, as of November 4, 2026. Enterprise is quoted per organization, so there is no public price.
- The seat price is the minimum bill. Third-party models such as Claude and GPT are billed from prepaid credit at the provider's list price, and Teams adds a $0.25 per million token Cursor Token Rate, so two developers on one plan can cost very different amounts.
- Nautili, an LLM gateway that tracks and controls model calls, can show spend per developer for Cursor traffic sent to a publicly reachable HTTPS OpenAI-compatible endpoint (Cursor routes these requests through its own servers first), and Cursor's own agent traffic needs the optional Cursor tap.
- Seat math is only a floor: after the pool is spent, 10 million input tokens to Claude Sonnet 5.5 cost $22.50 on input alone, at $2 per million tokens plus the $0.25 per million Cursor Token Rate.
- On a developer's own Cursor credential, this is tracking, not capping. Budgets and limits apply only to calls that use a Nautili-issued key.
Suppose we have a company where forty engineers use Cursor every day. The seat invoice looks the same each month, but top-up charges keep appearing on top of it, and nobody can say whether a few developers running long agent sessions on the largest model caused them or the whole team did. All finance has is a total, and the first question it asks is who is using the most.
The sections below cover what Cursor costs first, then how to get a per-developer view.
Cursor AI Pricing in 2026: How Much Cursor Costs per Developer
Cursor sells a monthly seat that includes a weekly pool of usage for Cursor's own models. Cursor's pricing page lists these individual plans, each sized as a multiple of Plus:
| Plan | Monthly price | Annual price | Included usage |
|---|---|---|---|
| Free | Monthly price$0 | Annual price$0 | Included usageLimited |
| Plus | Monthly price$8 | Annual price$80 | Included usageBase pool |
| Premium | Monthly price$30 | Annual price$300 | Included usage4x Plus |
| Super | Monthly price$100 | Annual price$1,000 | Included usage15x Plus |
| Ultra | Monthly price$200 | Annual price$2,000 | Included usage50x Plus |
Cursor became part of SpaceX when the $60 billion acquisition closed in mid-August 2026 (Techzine, Bloomberg Law). The X Subscription then launched on October 12, 2026, bundling Grok, the assistant from SpaceXSI (formerly xAI), and X features with the Cursor agent (announcement, Cursor help page). The seat prices above cover that bundle, while third-party models such as Claude and GPT are still billed separately by usage.
Annual prices come from Cursor's billing help page, which also lists the older plans for existing subscribers: Pro at $20, Pro+ at $60, and Teams seats at $40 and $120. A quote from your own account can differ from this table if it still sits on a legacy plan, and switching to the new structure is permanent.
The larger plans cost less per unit of usage. Dividing each monthly price by its multiple of the Plus pool gives $8.00 for Plus, $7.50 for Premium, $6.67 for Super, and $4.00 for Ultra.

What Cursor Usage Pools Mean in Plain Words
A usage pool is the amount of work a seat can do before extra charges start. Every paid plan has one weekly pool for Cursor's own models (Grok and Composer), shared across the agent, the CLI, cloud agents and the Grok apps, and it refreshes each week. Different models draw from the pool at different rates, so a short question on a light model uses little and a long agent run uses a lot.
Plus covers Cursor's own models only, and third-party models, which start at Premium, are handled differently:
- Not in the pool. On Premium and above, Claude, GPT and Gemini models are billed at the model's API list price from the first request, paid from prepaid credit.
- Credit, not a surprise invoice. You add credit with a top-up, or turn on auto top-up to refill a balance below a threshold.
- A monthly limit. A monthly additional usage limit caps paid usage each month, even if credit remains.
- No quality drop. When the pool runs out you can wait for the weekly reset, use credit or upgrade, and requests are never downgraded in quality or speed.
For scale, Claude Sonnet 5.5 is listed at $2 per million input tokens and $10 per million output tokens, and Claude Opus 5.5 at $4 and $20.
Cursor Teams Pricing Seat by Seat
Teams use the same seat tiers as individual plans, billed per user. Cursor's Teams pricing page lists three paid seat types and a free seat:
| Seat | Price per user per month | Weekly pool |
|---|---|---|
| Free | Price per user per month$0 | Weekly poolNone, draws on the member's personal plan |
| Premium | Price per user per month$30 | Weekly poolPremium pool |
| Super | Price per user per month$100 | Weekly pool3.75x Premium |
| Ultra | Price per user per month$200 | Weekly pool12.5x Premium |
Three Teams rules change how you forecast:
- Pools are per seat. Seats do not share a weekly pool, and unused usage does not move between teammates.
- Additional usage is shared. Overage and third-party model usage draw on one prepaid balance for the whole team.
- A Cursor Token Rate applies. Third-party models cost the public list price plus $0.25 per million tokens, while Cursor's own models beyond the pool are billed at their token rates with no Cursor Token Rate.
Admins can set one monthly additional usage limit for the team, a default limit per member and overrides per person. When the team limit is reached, paid usage pauses until next month or until an admin raises it, even if credit remains. Teams created before the current structure may still have Standard seats at $40 and Premium seats at $120.
How Cursor Enterprise Pricing Works for Teams
Cursor does not publish an Enterprise price, so every figure comes from a sales quote. Cursor's pricing page lists what Enterprise adds on top of Teams:
- Pooled usage shared between all users in a team, which Teams does not have.
- Invoice and purchase order billing.
- SCIM seat management, audit logs and service accounts.
- Granular spend controls, with group-level settings and spend limits.
- Repository, model and MCP access controls.
- Priority support.
When you compare Teams with Enterprise, ask for the pooled usage in writing, because it decides how often a heavy user pushes the team into paid additional usage. Ask whether the Cursor Token Rate applies to your contract, since Cursor's models and pricing page says it applies on Teams and Enterprise for eligible third-party models.
What Drives Cursor Cost Beyond the Seat Price
Five things move the bill, and a per-developer view helps with each:
- Model choice: A premium third-party model costs several times a light one per token, so a developer who defaults to the largest model spends far more than a teammate on Auto.
- Agent runs: Long agent sessions resend context on every step, and background and cloud agents run without a person watching.
- Context size: A large repository or many attached files raises the input tokens on each request.
- Auto routing mode: Auto in Cost mode draws from the weekly pool, while Balance and Intelligence need Cursor Router enabled on Teams or Enterprise and bill at the routed model's list price plus the Cursor Token Rate, except for the models on Cursor's exclusion list, which includes Haiku 5.5, Gemini 3 Flash and GPT-5 mini.
- Overage settings: Without a monthly additional usage limit, paid usage has no ceiling beyond the credit balance.
A Worked Cursor Cost Example at 10, 25 or 50 Seats
The numbers below are list-price seat math on monthly Teams prices, so they show the floor and exclude all additional usage. The seat mixes are examples, not a recommendation:
| Team size | Seat mix | Monthly seat cost |
|---|---|---|
| 10 seats | Seat mix10 Premium at $30 | Monthly seat cost$300 |
| 25 seats | Seat mix20 Premium at $30 and 5 Super at $100 | Monthly seat cost$1,100 |
| 50 seats | Seat mix35 Premium at $30, 10 Super at $100 and 5 Ultra at $200 | Monthly seat cost$3,050 |
Additional usage comes on top. Suppose one developer sends 10 million input tokens to Claude Sonnet 5.5 in a month after the pool is spent. At $2 per million tokens, that is $20, plus the Cursor Token Rate of $0.25 per million, which adds $2.50, for $22.50 on input alone, before output and cache tokens. Multiply that across a team and a seat table stops being a forecast.
Where Cursor Shows Spend for Each Developer Today
Cursor gives Teams admins centralized billing and usage views, while the analytics API and the per-user spend-limit endpoints are listed for Enterprise teams only, and balances and top-ups sit in the grok.com billing dashboard. These views cover what Cursor bills. They stop at the Cursor account, so spend from the same developers on other tools sits in separate places, and none of them ties a request to a project or an environment.
That is the gap a gateway fills. Observability in Nautili records latency, cost, tokens and cache outcome for every request that reaches it, which the LLM observability guide covers in depth.
What Nautili Can See in a Cursor Setup
Nautili is an LLM gateway, so it sees only the traffic that reaches it. There are two paths from Cursor.

Path 1: OpenAI-compatible calls
Cursor lets you override the OpenAI base URL and use your own key, but those requests route through Cursor's servers, so the endpoint must be a publicly reachable HTTPS address, which means a Nautili-run gateway (the Shared Gateway or a Hosted Gateway) or a public ingress on a self-hosted install. Point it at the Nautili OpenAI-compatible listener (port 8080 on a self-hosted install, or the OpenAI-compatible address your dashboard shows on a Nautili-run gateway) and use an issued sk-dz- key.
Custom keys cover OpenAI-family chat and agent requests, not Auto or Composer, and the Cursor Token Rate on Teams and Enterprise and the lack of zero data retention still apply. These requests are governed like any other keyed traffic, so per-developer attribution, budgets, model allowlists and rate limits all apply.
Path 2: Cursor's own agent traffic
Cursor's own models and agent cannot be repointed by a base URL. Nautili offers an optional Cursor tap that intercepts Cursor's own hosts using TLS interception. It is off by default, it needs the client to trust the tap's certificate authority and it needs sign-off from your IT team.
The developer's own credential is used on that traffic, so Nautili tracks it and cannot cap it, attributing each request to the Cursor user ID in the session token.
| Path 1: Override OpenAI Base URL | Path 2: Cursor tap | |
|---|---|---|
| Setup | Path 1: Override OpenAI Base URLBase URL plus an sk-dz- key in Cursor settings | Path 2: Cursor tapOptional listener, certificate trust, IT sign-off |
| Per-developer attribution | Path 1: Override OpenAI Base URLYes | Path 2: Cursor tapYes |
| Budgets and model allowlists | Path 1: Override OpenAI Base URLYes | Path 2: Cursor tapNo |
| What it covers | Path 1: Override OpenAI Base URLOpenAI-family chat and agent calls sent to your override endpoint, not Auto or Composer | Path 2: Cursor tapCursor's own agent traffic |
Pick Path 1 when you want limits and accept that only those calls run through the gateway. Add Path 2 when finance needs the full picture, and IT has approved it.
Set Up Per-Developer Tracking for Cursor
Setup takes four steps per developer:
- Issue a key for each developer from the Keys tab of the Governance page, so it is bound to that person, and copy it straight away, because it is shown only once.
- In Cursor's model settings, turn on the OpenAI override and paste your Nautili OpenAI-compatible address and the
sk-dz-key. - Add each developer to their team in Nautili. Cursor has no custom-header setting, so attribution follows the key owner, and each person's keys roll up on the Teams page once they are in their team.
- Open the spend views in Nautili to see usage by person and team.

To verify, send one prompt from Cursor and open the request list in Nautili. A new row should appear within a few seconds, attributed to the developer who owns the key.

Capping Cursor Spend With Nautili Budgets
A cap needs a credential Nautili controls and a Pay-as-you-go plan (the Demo tier has no budgets), so it applies to Path 1 calls on an issued key and never to a developer's own Cursor credential. The LLM governance guide covers budgets and enforcement modes, and the Nautili Cursor setup docs list the connect steps.
Where to Start With Cursor Cost Tracking
Cursor's seat price is the floor of what a team pays, and the real bill is set by model choice, agent runs and overage on top of it. A per-developer view turns that from a monthly surprise into something a team can review and act on. Nautili gives that view for every call that reaches it, and adds budgets wherever the call carries an issued key.
A practical first week looks like this:
- Day one, issue a key for one developer, point Cursor's OpenAI override at the Nautili address, and send a test prompt to confirm a row appears under that person.
- First week, extend keys to the rest of the team, add each developer to their team in Nautili so keys roll up by team, and review spend by person and team.
- After that, set budgets on the keys that need a ceiling, and ask your IT team whether the optional Cursor tap is worth enabling to cover Cursor's own agent traffic.
The easiest way to begin is with one developer. Give them an issued key, point Cursor at Nautili, and after a week you will have real numbers on whether the team needs spending caps or just a clearer view of who spends what. There is nothing to install, because every team already has a Shared Gateway, so you can create that first key in the Nautili dashboard today.
FAQs
How much does Cursor cost per developer per month?
Individual plans run from $0 to $200 and Teams seats from $30 to $200 per user, as of November 4, 2026. Usage beyond the included pool is billed on top, and third-party models are billed at list price from prepaid credit.
How much is Cursor per month for a team of 10?
At list prices, ten Premium seats on Teams cost $300 a month, and ten Super seats cost $1,000. Additional usage and the Cursor Token Rate are extra.
Does Cursor Enterprise have a fixed price?
No. Enterprise is quoted per organization and adds pooled usage, SCIM, audit logs, invoicing and granular spend controls.
Why is my Cursor bill higher than the seat price?
Seats include a weekly pool for Cursor models only. Third-party models, agent-heavy usage and anything past the pool draw on paid additional usage, which Teams bills from a shared prepaid balance.
Can I see how much each developer spends in Cursor?
Yes, for traffic that reaches Nautili. Calls sent through the OpenAI override are attributed per developer, and Cursor's own agent traffic is covered only if you enable the optional Cursor tap.
Can Nautili cap Cursor spend?
Only for calls that use a Nautili issued key. Traffic that carries a developer's own Cursor credential is tracked, not capped.
Written by
Nautili team


