Claude Code vs Codex vs Cursor: What a 50-Engineer Team Pays on Each (2026)

TL;DR

At list price, seats for 50 engineers cost $1,000–5,000 a month on Claude Team, $1,000 on ChatGPT Business with Codex, and $1,500 on Cursor Teams Premium. Those numbers look comparable and aren't. Each vendor meters differently: Claude sells an allowance on rolling five-hour and weekly windows, Codex moves to credits once limits run out, and Cursor includes a weekly pool for its own models while billing Claude and GPT models at API list price. What a seat buys also differs by an order of magnitude. On our own accounts, a fully used Claude Premium seat is worth roughly $4,900 of API-rate usage a month (measured), and a $100 Codex Pro plan roughly $1,200–1,500 (measured). The one unit that adds across all three is API-equivalent dollars.

This post covers how each vendor meters, what a seat is worth in that unit, a worked 50-engineer budget with the assumptions written down, and what to do if your team uses more than one tool.

How each vendor meters usage

The price on the page tells you less than the meter behind it. Three different mechanisms are in play.

Claude Code (Claude Team and Enterprise). A Team seat comes with a usage allowance that resets on a rolling five-hour window and a weekly window, shared with Claude chat. Standard seats cost $20 per month billed annually ($25 monthly); Premium seats cost $100 ($125) and carry "5x more usage than standard seats," per Anthropic's pricing page. Team covers 2 to 150 seats. Past the allowance, usage credits are billed at API rates. Enterprise flips the model: $20 per seat per month billed annually, a 20-seat minimum, and all usage billed at API rates. On a seat, Anthropic's cost guide notes, usage inside the allowance "isn't metered in dollars."

Codex (ChatGPT Business, Enterprise and Pro). ChatGPT Business costs $20 per user per month billed annually for two or more users, or $25 monthly, per OpenAI's pricing page. Codex usage on a standard Business seat runs against five-hour limits, with weekly limits that "may also apply." OpenAI publishes those limits as message estimates, not dollars: 15–160 local messages per five hours on GPT-6.1 Sol, 5–45 on GPT-6 Astra. Past them, usage draws from ChatGPT credits, which are priced per million tokens (50 credits per million input tokens and 250 per million output on GPT-6.1 Sol). The dollar price of a credit is not on the page: "credit purchase prices and applicable discounts depend on your plan or agreement." Enterprise pricing is contact-sales. Individual Pro plans cost $100, $200 or $500 a month. One more wrinkle: OpenAI's pay-as-you-go Codex seats closed to new Business workspaces in June 2026, though Enterprise still offers usage-based Codex seats.

Cursor (Teams and Enterprise). Cursor's current pricing docs list Teams seats at $30 (Premium), $100 (Super) and $200 (Ultra) per seat per month, with usage of 4x, 15x and 50x the Plus plan respectively. Seat tiers can be mixed on one team. Each seat includes a pool for Cursor's own models (Grok 4.7, 4.6, 4.5 and Composer 2.5) that refreshes weekly. Claude, GPT and Gemini models are outside that pool: on Teams they bill at API list price plus a "Cursor Token Rate" of $0.25 per million tokens, applied to input, output and cached tokens. Overflow on Cursor models is paid from one shared prepaid team balance. Cursor doesn't publish the pool's dollar value, and annual pricing is listed for individual plans only. Existing teams on the older Standard and Premium seats keep monthly pools.

So a Claude seat is a time-windowed allowance, a Codex seat is a message-estimated allowance with a credit tail, and a Cursor seat is a weekly pool for one family of models with metered billing for everything else.

What a seat buys in API-equivalent dollars

A seat price is what you pay. The useful number is what it buys, which we measure by pricing the tokens a plan consumed at the vendor's public API list rate and dividing by how much of the limit they used. None of the three vendors publishes this figure, so what follows is Promptster's own measurement on single accounts, labelled by how we got it.

Read the Claude rows as ceilings. A Premium seat delivering 40–50 times its price assumes every window is run to the limit, which only your heaviest users do. Anthropic's own average for Claude Code is $150–250 per developer per month at API rates, which sits inside even a Standard seat's derived allowance on a monthly basis. The five-hour window is where Standard pinches: at about $40 per window, one long agent session on a busy morning can use it up, and Anthropic drains five-hour limits faster on weekday mornings Pacific time.

The Codex figure moved under us, too. When the account's default model switched from GPT-6 Astra to GPT-6.1 Sol, a point of the weekly limit bought about 21% fewer API dollars, with no change to the $100 price. The exchange rate between a seat and API dollars is set by the vendor and the model, and it changes without an invoice changing.

A worked budget for 50 engineers

Assumptions, so you can swap in your own:

• 50 engineers, each using one tool as their daily coding agent.
• Comparable work on each tool, sized with Anthropic's $150–250 per developer per month at API rates. That figure is Claude-specific; the same work priced on other vendors' models will differ, so treat it as a workload placeholder.
• List prices, no negotiated discounts. Annual billing where the vendor publishes it; Cursor Teams at its listed monthly price.

The fixed column is the easy part and the least informative. Three things move the totals:

1. Where the distribution's top sits. Anthropic says 90% of users stay under $30 per active day, more than double the $13 average. On a seat plan the top 10% are the ones who exhaust allowances and generate overflow billing.
2. Which models run inside the included usage. On Cursor, a team that defaults to Grok or Composer stays in the pool; a team that defaults to Claude Opus pays API rates on almost everything, so the seat is mostly an access fee.
3. Cache-heavy sessions and flat per-token fees. Cursor's $0.25 per million token rate applies to cached tokens too, and cached reads are the cheapest thing an agent does. Take one turn in a session holding 150,000 tokens of cached context on Opus 5.5: at Anthropic's $0.20 per million cache-read rate that context costs $0.03; the token rate adds $0.0375. For long agent sessions, where most tokens are cache reads, the flat fee can more than double the context portion of the bill.

Why the three invoices don't compare

Line up a month of invoices and you get three different units. Anthropic's seat invoice reads $5,000 and says nothing about the roughly $4,900-per-seat ceiling underneath it. OpenAI's reads $1,000 plus a credit balance whose dollar value depends on your contract. Cursor's reads $1,500 plus a top-up balance plus API-list charges for third-party models. Finance can add the dollar totals, but those totals measure price paid, not work bought, and they can't tell you which engineers are near a limit or which tool did the same task for less.

API-equivalent dollars fix this by changing what gets counted. Instead of the invoice, you take the tokens each session consumed (input, cached input, cache writes, output), price them at the vendor's public API rate for the model used, and sum. The result is independent of how the vendor packaged the sale. A Claude seat, a Codex credit and a Cursor pool all reduce to tokens at list price, so the numbers add across vendors and you can compare a seat's price against the usage it carried. This is the core move of TokenOps, and the metrics built on it all assume one unit.

The catch: you need token-level usage from every tool, attributed to who and what produced it. Vendor dashboards each cover their own product, and none of them prices a competitor's usage.

What mixed-tool teams should do

Many teams run two or three of these at once: Cursor in the editor, Claude Code or Codex in the terminal, an API key in CI. A workable approach:

1. Put everything on one ledger. Seats, credits, pools and API keys, all priced in API-equivalent dollars. Attribute it by repo and workflow so the question becomes "what did this migration cost?" instead of "what did Cursor cost?"
2. Tier seats by measured use. Mixed tiers exist on Claude Team and Cursor Teams for a reason. An engineer who never fills a Standard window doesn't need Premium; one who hits the wall every morning is costing you waiting time.
3. Check where each tool's models are billed. Running Claude models through Cursor and through Claude Code are two different price structures for the same tokens.
4. Separate waste from work. Carried context, re-reads and oversized default models are recoverable token waste. Removing them lowers the bill without lowering output, which a seat-count cut can't promise.
5. Re-measure after vendor changes. Model launches, limit changes and peak-hour rules all move what a seat buys.

For tool-by-tool depth, see our breakdowns of Claude Code, Codex and Cursor team costs, and the spend management tools that try to unify them.

Promptster Teams puts all three on one ledger

Promptster Teams attributes AI coding spend across Claude Code, Codex and Cursor by repo and workflow, priced at API rates so seat plans 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, so you can tell a seat that's earning its price from one that's carrying re-billed context. Code and diffs are redacted on the engineer's machine before upload, and it is not developer monitoring.

See how Promptster Teams compares AI coding spend across tools →

Related: How much does Codex cost a team? · How much does Cursor cost a team? · Claude Team vs Enterprise vs API · How much does Claude Code cost a team? · What a $100 AI coding plan is worth · What is TokenOps?