What AI Coding Tools Cost: Cursor, Claude Code, Copilot, Codex, and the 2 Ways They Bill

il y a 3 minutes
4 min de lecture

The AI coding tool market has converged on 4 price points.

$10 to $20 buys an individual seat,
$39 buys a bigger one at GitHub,
$100 buys a heavy tier
and $200 buys the ceiling, at 3 different vendors each.

The seat prices tell you almost nothing. What separates these tools on an invoice is a structural choice most buyers never see: who controls the API call.

This post prices the 5 tools that matter, explains the 2 billing architectures behind them, and shows where the budget actually breaks. Prices are list prices verified on the vendors' pages on August 30, 2026.

The seat price ladder

Tool	Individual tiers	Team tiers	Overage model
GitHub Copilot	Free, Pro $10, Pro+ $39, Max $100	Business $19/seat, Enterprise $39/seat	AI Credits at $0.01 each, drawn on model cost
Cursor	Pro $20, Pro+ (3x pool), Ultra (20x pool)	Teams Standard $40/seat, Premium (5x)	On-demand usage at model rates, billed in arrears
Claude Code	Via Claude plans: Pro $20, Max $100 (5x), Max $200 (20x)	Team, Enterprise	Rate limit, or BYOK at API rates
OpenAI Codex	Via ChatGPT plans: Plus $20, Pro $100	Business $25-30/seat	Plan limits, or BYOK at API rates
Devin Desktop (ex-Windsurf)	Free, Pro $20, Max $200	Teams $80 base + $40/seat	Extra usage at API pricing

Bar chart of individual seat prices for AI coding tools in August 2026, from GitHub Copilot Pro at $10 to Claude Max 20x and Devin Max at $200, showing the market's convergence on 4 price points.

A calibration note: seat prices are the most frequently repriced figures in this category. Cursor restructured its tiers twice this year, Windsurf retired its credit system in March and its own name in June. The table is a shape comparison, verified August 30, 2026; check the vendor's page before building a forecast on any cell.

Two billing architectures, one invisible difference

Every tool above is one of 2 things.

Cursor, Copilot and Devin are vendor-mediated: you pay the tool vendor, the vendor calls the models, and your cost visibility is whatever its admin dashboard exposes.
Claude Code and Codex are also sold as subscriptions (through the Claude plans and ChatGPT plans we covered earlier in this series), but both switch to BYOK mode: your own API key, billed per token by Anthropic or OpenAI directly.

The distinction decides everything FinOps cares about.

On vendor-mediated tools you cannot inject metadata into a request, so attribution stops at a list of developer emails.
On BYOK you can route every call through a gateway (LiteLLM, Portkey), tag it with team and project, enforce per-team budget caps and see all tools in one place.

The trade: nobody builds the dashboard for you.

What changed at GitHub in June

Copilot overage used to cost a flat $0.04 per premium request. On June 1, 2026, GitHub replaced it with AI Credits: each credit is worth $0.01, plans include a monthly allowance ($15 on Pro, $70 on Pro+, $200 on Max), and requests draw credits based on the underlying model's token cost. Completions stay unlimited; chat, agents and code review consume credits.

The change looks cosmetic and is not. A flat per-request rate made overage forecastable from request volume alone. Credit pricing makes it a function of volume and model mix, so a team that changes its default model sees spend move with no change in headcount or behavior.

If you run Copilot, reconcile the first credit-billed months against your pre-June baseline per developer; the variance concentrates in whoever routes to the most expensive models.

Where budgets actually break

Subscription seats are self-capping. A Cursor Pro or Claude Max developer who exhausts the included pool hits a rate limit, not an invoice: the worst case is a bounded monthly number. Most governance attention goes here, because the invoice is legible.

The unbounded side is BYOK and agentic use. A raw API key has no ceiling; an agent looping on that key, or a background job left running overnight, bills per token until someone notices, and the charge lands on the provider bill 24 to 48 hours later.

For scale: Anthropic's published figures put the average Claude Code user on API-key mode at about $6/day, with 90% of users under $12/day; a full-time heavy user runs $100 to $200 per month, which is why the Max plans exist.

The mistake we see is spending governance effort in proportion to invoice legibility instead of unbounded risk: audited seat counts, and an unmonitored API key in a CI pipeline.

5 levers that move the invoice

5 levers:

Govern model routing first. The gap between the cheapest and priciest model inside one tool runs 10x to 50x. A team that defaults every completion to a frontier reasoning model pays that multiple for routine work.
Make premium modes opt-in. Cursor's Max mode fills the full context window on every request; Claude Code's Fast mode doubles the Opus token rate. Both are legitimate per task and expensive as an organization-wide default.
Right-size the tier against the overage ratio. If overage consistently exceeds the seat price, the tier is undersized; if the included pool goes unconsumed, you are over-provisioned. One ratio, checked monthly.
Audit seats and overlap together. The same developer paying for Cursor Teams at $40 and a Claude Max plan at $100 is common and sometimes justified; 2 billing streams nobody compares is not. Reclaim seats idle for 30+ days, and note that Z.ai now sells an $18/month coding plan into the same budget line.
Track one unit number: AI spend per merged PR. Invoice divided by merged pull requests, per team, per month. A step change means spend outran output or the reverse, and either is worth a look. Use it to size budgets, never to rank developers; the moment it appraises people, PRs get split and the number stops measuring anything.

Where to start

Same exercise as the previous 3 posts, adapted to this category:

List every coding-tool seat, every API key developers use alongside them, and which billing stream each developer appears in.
Then put a budget cap on every raw key, at the gateway or in the provider console. The seats are bounded by design. The keys are bounded only if you bound them.

The FinOps skill OptimNow uses for this analysis, including the full AI dev-tools reference, is open source under CC BY-SA: github.com/OptimNow/cloud-finops-skills. Download it, load it into your own Claude and run the same analysis on your invoice.