A practitioner's reference for understanding how GitHub Copilot, Cursor, Claude Code, Windsurf, Amazon Kiro, and OpenAI Codex actually bill you — credits, tokens, premium requests, multipliers, and what happens when you hit the wall. Built for engineering leads and FinOps teams who need accurate numbers, not marketing copy.
Last updated: May 2026. Pricing in this category changes monthly — verify figures against each vendor's official page before committing. See Contributing / Corrections if something is outdated.
- Executive summary table — all 6 tools, billing units, and overage behavior in one view
- Billing unit decoder — credits vs tokens vs premium requests vs flat capacity
- Per-tool breakdowns — Copilot, Claude Code, Cursor, Codex, Windsurf, Kiro
- Copilot June 1 billing change — the flex-billing transition every team needs to model now
- The $20 tier showdown — which entry-level plan survives real agentic work
- Claude Code Max deep dive — what the capacity multipliers mean in practice
- Cost calculation framework — 4 steps to find your real monthly bill
- Enterprise governance — pooled credits, caps, chargeback models
data/pricing-2026.csv— machine-readable pricing data for all 6 toolsCHEATSHEET.md— one-page quick reference for billing units, caps, and decision rulesCOST-CALCULATOR.md— step-by-step worksheet to compute your real monthly bill
The two facts that predict your bill better than the headline price: the billing unit and the overage behavior.
| Tool | Entry price | Billing unit | At the limit |
|---|---|---|---|
| GitHub Copilot | $10 Pro / $39 Pro+ | Premium requests → AI Credits (from Jun 1) | Usage-based flex beyond allowance |
| Claude Code | $20 Pro / $100 Max 5x / $200 Max 20x | Subscription capacity | You wait for reset (no overage) |
| Cursor | $20 Pro / $60 Pro+ / $200 Ultra | Compute credits | Credits deplete; overage applies |
| OpenAI Codex | Bundled in paid ChatGPT; team token seats | Raw tokens | Bills purely on consumption, no ceiling |
| Windsurf | $20 Pro / $200 Max | Quotas + Devin bundle | Hard quota cutoffs, no overage |
| Amazon Kiro | $20 Pro (1,000 credits) | Credits (opacity reported) | Credits drain; can bill beyond base |
One-line takeaway: Flat-rate plans trade a higher floor for a predictable ceiling; metered plans trade a low floor for an open-ended ceiling. Heavy agentic users almost always come out ahead on flat rate.
Full pricing breakdown: AI Coding Tool Pricing: The Credit Trap Vendors Hide
Vendors have replaced flat per-seat pricing with proprietary, metered units engineered to obscure true cost. You cannot compare plans priced in different units without converting them to a common measure: dollars per unit of your actual work.
Credits are an abstract currency (Cursor, Kiro). One action costs a variable number of credits depending on the model and task complexity — which is precisely why they're hard to forecast. The most dangerous mechanism is the credit multiplier: premium models consume credits at a steep multiple of the base rate. Claude Opus-class models have been reported to trigger multipliers around 2.2×. Switching your default IDE model is often the real reason a bill doubles, not increased usage.
Premium requests are round-number actions against a frontier model (Copilot). One request is roughly one prompt-and-response cycle, regardless of text length. More forecastable than tokens, but a single agentic bug-fix session can still consume 20–50 of them in an afternoon.
Tokens are the rawest unit (Codex, direct API). You pay strictly by text volume. Long contexts and large repositories get expensive quietly and rapidly — roughly four characters per token.
Subscription capacity (Claude Code) is the cleanest model: hit the limit and you wait for a time-based reset rather than incurring overages. The ceiling is hard; the failure mode is a pause, not an invoice.
Daily caps vs. monthly quotas: A monthly quota provides a bulk allocation for the billing cycle. Daily caps restrict burst usage, preventing engineers from running heavy agentic refactoring in a single sprint even if monthly quota remains.
Full technical breakdown: AI Coding Credits vs Tokens Explained
Copilot is the cheapest serious entry point for autocomplete and chat. Pro includes unlimited standard completions plus roughly 300 premium requests per month; Pro+ raises that to roughly 1,500 and unlocks more models.
The problem is agentic work: a single agent bug-fix session can consume 20–50 premium requests. At that rate, Pro's 300-request allowance lasts under two weeks of real agent use. Note that new Pro and Pro+ signups were paused in April 2026 — check current availability.
The June 1 billing change is the critical event to model. On June 1, 2026, Copilot Pro and Pro+ move to usage-based "AI Credits" flex billing, where one credit equals $0.01. The $10 and $39 sticker prices reportedly hold, but once you exceed the base allowance, every subsequent agent action incurs overage at the credit rate. A team that assumed a predictable $39/month seat now has a variable bill.
| Tier | Price | Premium requests/month | At the limit (post Jun 1) |
|---|---|---|---|
| Free | $0 | ~50 | Hard stop |
| Pro | $10 | ~300 | Flex billing at $0.01/credit |
| Pro+ | $39 | ~1,500 | Flex billing at $0.01/credit |
Full breakdown: Why Your GitHub Copilot Bill Changes on June 1 | Copilot's 300 Premium Requests: When You Hit the Wall
Claude Code is the easiest plan to budget. Pro, Max 5x, and Max 20x are flat subscriptions — hit a limit and you wait for a time-based reset rather than paying overage. That predictability is worth more than a lower sticker price for developers running agents daily.
The "5x" and "20x" multipliers reference the baseline capacity of the $20 Pro plan. In practice:
- Max 5x ($100): Survives roughly 2–3 days of heavy continuous agentic work before triggering a cooldown. Comfortably handles mixed chat + agent workflows for most engineers.
- Max 20x ($200): Designed to sustain a full-time senior developer running continuous autonomous agents through a full work week without interruption.
- Pro ($20): Sufficient for standard chat and autocomplete; capacity limits make it insufficient for daily heavy agent use.
Raw API access looks appealing when Max limits are hit, but agentic tools consume massive context windows per loop. Paying per-token via API for agentic work can easily exceed $200/month.
| Tier | Price | Capacity vs Pro | Overage model |
|---|---|---|---|
| Pro | $20 | 1× baseline | None — wait for reset |
| Max 5x | $100 | 5× baseline | None — wait for reset |
| Max 20x | $200 | 20× baseline | None — wait for reset |
Full breakdown: Claude Code Max: The True Cost of $100 vs $200
Cursor uses compute-based credit billing. Frontier models and heavy "Auto mode" usage deplete credits faster than the base plan includes; effective cost tracks how aggressive your model choices are.
The primary cost-control lever most users miss: Cursor's in-house Composer 2.5 model (shipped May 2026) is markedly cheaper per token than frontier models. Routing standard daily tasks through Composer 2.5 instead of Claude Opus or GPT-4-class models is the single most effective way to stretch your base allocation.
When fast credits run out mid-session, the IDE doesn't shut off but wait times spike. To restore velocity, users must either enable usage-based overage (transforming a fixed cost into a variable liability) or upgrade.
| Tier | Price | Credits | Overage model |
|---|---|---|---|
| Pro | $20 | Fixed monthly fast-credit pool | Usage-based after depletion |
| Pro+ | $60 | Expanded pool | Usage-based after depletion |
| Ultra | $200 | Highest pool — rarely exceeded | Usage-based after depletion |
Full breakdown: Cursor's Credit System Is Quietly Draining Your Plan
Codex access is bundled into paid ChatGPT plans (Plus, Pro, Business, Enterprise). The 2026 change: Codex-only team seats that bill purely on token consumption with no ceiling. That's maximum flexibility and maximum risk.
OpenAI cites roughly $100–$200 per developer per month for active Codex use. "Bundled" does not mean "cheap" at scale. For long-context, large-repo work, token billing is where costs scale exponentially — budget specifically for it.
Windsurf raised Pro from $15 to $20 in 2026 but now bundles the Devin Cloud agent and Devin CLI at the same price — arguably the best value move in the segment if you'd otherwise pay for Devin separately.
Windsurf enforces hard quotas rather than flex billing. When an engineer exhausts their allocation, access is downgraded to slower models — no surprise overage invoice. The Max ($200) tier massively expands quotas for senior engineers running Devin for full-day autonomous execution.
The workflow distinction vs Cursor: Cursor is for developers who want to co-author code actively; Windsurf/Devin is for teams who want to delegate an entire feature spec to an autonomous agent and walk away.
Full breakdown: Windsurf Raised Its Price — Is the Devin Bundle Worth It?
Kiro went GA in early 2026 with a $20 / 1,000-credit Pro plan. Early users report opaque, faster-than-expected credit drain. The culprit: Kiro's spec-driven workflow forces the AI to continuously validate output against requirements, generating multiple hidden prompts per visible action. Heavy architectural queries or repository-wide indexing can cost dozens of credits at a time.
The UI lacks real-time, granular cost attribution. Treat Kiro's budgeting as unproven until your own usage data confirms otherwise. Only deploy it in production environments if you have hard spend caps and IAM policies in place.
Full breakdown: Amazon Kiro Credits: The Drain AWS Won't Explain
This is the most urgent FinOps event of mid-2026 for any team running on Copilot. On June 1, 2026, Copilot Pro and Pro+ migrate to usage-based "AI Credits" flex billing.
Key facts:
- 1 AI Credit = $0.01
- Sticker prices ($10 and $39) reportedly hold, covering a base allowance
- Once the allowance is exhausted, every subsequent agent action incurs overage at the credit rate
- New Pro and Pro+ signups were paused in April 2026 ahead of the transition
- Premium models (like Opus 4.7) trigger credit multipliers, draining balances faster than base models
PMO action required: Re-baseline Copilot spend against your heaviest sprint week before June 1 — not your monthly average. Averages hide the overage events that blow budgets.
Full breakdown: Why Your GitHub Copilot Bill Changes on June 1
At the $20 price point, the underlying compute capacity varies by orders of magnitude.
| Tool | $20 plan | Overage model | Best for |
|---|---|---|---|
| Claude Code Pro | $20 | None — hard reset, no overage | Teams prioritizing budget safety |
| Cursor Pro | $20 | Usage-based after fast credits | Active co-coding, model-switching |
| Windsurf Pro | $20 | Hard quota cutoff, no overage | Autonomous delegation to Devin |
| Kiro Pro | $20 (1,000 credits) | Credits drain, billing unclear | Spec-driven teams with spend caps |
| Copilot Pro | $10 | Flex billing post-Jun 1 | Basic autocomplete; watch agents |
Lowest overage risk at $20: Claude Code Pro — when you hit the limit, you wait for a time-based reset. No variable invoice.
Best autonomous agent value at $20: Windsurf Pro — the Devin bundle provides autonomous execution capabilities that would otherwise require a separate enterprise contract.
The $30/month two-tool stack: Combine Copilot Pro ($10) with Claude Code Pro or Cursor Pro ($20). Use Copilot for unlimited inline tab-completions; preserve your $20 tool's compute credits for deep multi-file agentic reasoning.
Full breakdown: The Best $20 AI Coding Tool: 6 Plans, 1 Winner
The "5x" and "20x" labels reference the baseline capacity of the $20 Claude Code Pro plan. They govern total context window consumption, not just visible prompts.
Every time Claude Code reads your repository to plan a multi-file edit, it burns hidden capacity budget. Autonomous agent loops are exponentially more expensive than chat sessions.
Realistic expectations:
- Max 5x ($100): Approximately 15–20 hours of heavy continuous agentic loops per week. Most engineers find it survives 2–3 days of full-agent work before triggering a cooldown.
- Max 20x ($200): Designed for full-time senior engineers running continuous autonomous agents throughout the entire work week.
When you hit the limit: you are paused, not charged. The system forces you to wait for a time-based reset window. No overage invoice.
For comparison: Claude Code Max 20x vs Cursor Ultra ($200) — Claude Code wins on absolute budget safety (hard resets, no overage). Cursor offers more nuanced control over which models consume your allocation.
Full breakdown: Claude Code Max: The True Cost of $100 vs $200
Stop comparing sticker prices. Run this instead.
Step 1 — Measure your real consumption pattern. Count agentic sessions per developer per day and classify: autocomplete-only, chat-assisted, or full agent (multi-file edits, test runs). Use your heaviest sprint week as the planning baseline — averages will mislead you precisely when it matters.
Step 2 — Match the billing unit to the workflow. Predictable, bursty work tolerates metered credits. Continuous, heavy agent work demands a flat ceiling. Long-context, large-repo work is where token billing punishes hardest — budget for it specifically.
Step 3 — Model the overage, not the sticker price. Multiply your heaviest-week session count by the premium requests or credits each session consumes, then compare against every plan's allowance and overage rate. The cheapest headline price is rarely the winner.
Step 4 — Re-audit quarterly. Prices, credit multipliers, and model defaults shift constantly. Windsurf re-priced twice in a year; Copilot's billing model changed mid-2026. An annual lock-in negotiated in January can be the wrong tool by July.
Use the COST-CALCULATOR.md worksheet to run these steps with your team's actual numbers.
Full breakdown: AI Coding Cost Calculator: Find Your Real Monthly Bill
Individual developer optimization is a micro-level fix. Engineering directors need macro-level fleet governance.
Pooled credits vs per-seat budgeting: Several platforms pool credits across a team, smoothing individual spikes but removing per-person accountability. A heavy user can silently consume a quiet colleague's allocation. Decide deliberately: pooling for flexibility, or per-seat for attribution.
Three mandatory controls before rollout: spend caps that actually stop overage; audit logs of agent activity; admin control over which models and MCP servers developers can invoke. Without these, "usage-based" means "unbounded."
Internal chargeback model: Attribute AI coding spend back to the product or squad that generated it, exactly like cloud chargeback. This converts an opaque central cost into a signal each team can manage — and is the single most effective brake on runaway spend. Teams that apply cloud FinOps discipline to AI coding spend 30–50% less for the same output.
Developer profiles for forecasting:
- Light (autocomplete only): $10–$20/month
- Medium (chat-assisted): $20–$40/month
- Heavy (continuous agents): $60–$200/month
| File | What it contains |
|---|---|
data/pricing-2026.csv |
All 6 tools × all tiers: price, billing unit, allowance, overage rate, reset model |
data/README.md |
Column definitions and source notes for the CSV |
CHEATSHEET.md |
One-page quick reference: billing unit decoder, caps, multiplier table, decision rules |
COST-CALCULATOR.md |
Step-by-step worksheet to convert sessions/day into a real monthly bill per tool |
All facts in this repo trace to these source articles, published May 2026:
- AI Coding Tool Pricing: The Credit Trap Vendors Hide
- AI Coding Credits vs Tokens Explained
- AI Coding Cost Calculator: Find Your Real Monthly Bill
- Cursor vs Claude Code vs Copilot: Real 2026 Cost
- The Best $20 AI Coding Tool: 6 Plans, 1 Winner
- Claude Code Max: The True Cost of $100 vs $200
- Copilot's 300 Premium Requests: When You Hit the Wall
- Why Your GitHub Copilot Bill Changes on June 1
- Cursor's Credit System Is Quietly Draining Your Plan
- Amazon Kiro Credits: The Drain AWS Won't Explain
- Windsurf Raised Its Price — Is the Devin Bundle Worth It?
Pricing in this space changes monthly. If a number is stale, a new tier has launched, or a tool has changed its billing model, please open an issue or submit a PR.
Specifically useful contributions:
- Updated allowance numbers (premium requests, credit pools)
- Real-world usage data from your own team (anonymized)
- New tools that belong in the comparison
- Corrections to the multiplier table in
CHEATSHEET.md
Intended update cadence: quarterly (or immediately after a major billing-model change like the Copilot June 1 switch).
Rishabh Saini is an AI Tools & Content Engineer passionate about artificial intelligence, automation, and creative technology. He is currently working with AgileWoW, an AI and Agile-focused learning and consulting platform that helps teams and organizations adopt modern AI-driven workflows and agile practices.