LLM API pricing is only one of three ways an AI coding tool bills you: the other two are a flat monthly subscription and a usage-based credit pool sitting on top of that same raw token rate. Which one is cheapest depends on how much you actually run through it, not which vendor's homepage you read first. This piece works the math for three real usage patterns, states every assumption, and separates the tool's own billing model from the model provider's raw pricing underneath it, the layer that just moved on its own clock.
My Cursor bill jumped by about $20 in a month where I hadn't changed anything I could point to. Same three projects, same rough daily routine, same laptop. What had actually shifted was which model Auto picked for me across a run of longer sessions, and I only found that by reading the usage page line by line, not by staring at the invoice total. That's the thing about this category: the sticker price on the pricing page is the least interesting number on it.
The two strongest cost guides in this space both learned that the hard way this year. One built a detailed multiplier table on top of GitHub Copilot's old premium-request system. The other built a rate-limits guide against that same pre-June-2026 billing mechanic. Both describe a system that no longer calculates the bill. Neither covers Cursor or Claude Code at all, and nobody in the category has published a worked monthly number at a stated usage pattern that a reader could reproduce. That's what this article does instead.
Subscriptions, Credits, and LLM API Pricing
Every AI coding tool on the market bills you one of three ways, and most developers only clearly understand the one they happen to be using.
A flat subscription charges a fixed price per month, full stop. Cursor Pro at $20 and GitHub Copilot Pro at $10 make the simplest copilot vs cursor pricing comparison in the category (our head-to-head covers the tool-level call), and Claude Pro, the subscription that includes Claude Code CLI access, at $20 billed monthly (or $17 a month billed annually), works the same way. It optimizes for predictability: you know your ceiling before the month starts. It breaks down at the edges, either you're a light user quietly subsidizing a plan you barely touch, or you're a heavy user who blows past the soft cap and gets throttled, bumped up a tier, or billed for overage, depending on the vendor.
Usage-based credits sit in the middle. You still pay a flat subscription, but it comes bundled with a pool of credits denominated in real token cost, and anything past that pool gets billed at the underlying per-token rate. GitHub Copilot moved its entire lineup to this model on June 1, 2026, replacing flat premium-request counting with credits priced at $0.01 each against published per-model, per-token rates. Cursor's on-demand billing works the same way once you exceed a plan's included pool. It optimizes for a floor that scales: light months cost the subscription price, heavy months cost more, and you can see the meter moving if you bother to check. It breaks down when you don't know which model your session actually used, because the credit burn rate can be five to ten times different between a cheap model and an expensive one for the exact same task.
Raw API tokens skip the subscription layer entirely: this is LLM API pricing in its unwrapped form. You pay the model provider directly, per million input and output tokens, with no bundled floor and no vendor markup sitting in between. This is how bring-your-own-key tools like Cline work, and it's also an option for Claude Code and several others if you'd rather meter usage yourself than buy a seat. It optimizes for cost matching exactly to what you did, which is why our own math on Cline vs Cursor found a real crossover point where paying per token beats a flat subscription below roughly 35 to 40 agent turns a day. It breaks down at high, steady volume, where the predictability of a flat plan would have been worth paying a premium for, and it's the layer most exposed to the price swings later in this article.
Same category, three different mechanics. Most tools sit in more than one column depending on the plan you pick, so the mistake is comparing sticker prices across columns instead of matching a column to how you work.
An LLM Cost Comparison for Three Real Usage Patterns
No LLM pricing comparison in this category publishes a monthly number you could reproduce yourself. Here are three, with every assumption stated, so you can swap in your own numbers and get your own answer instead of trusting mine.
The light autocomplete user. Twenty-one working days a month, mostly inline completions, with about ten short chat or agent exchanges a day total, not full agentic sessions. Call each exchange 2,000 input tokens (file context plus prompt) and 500 output tokens (a small edit or a short answer). That's 210 exchanges a month: 420,000 input tokens and 105,000 output tokens. On GitHub Copilot's included lightweight model, GPT-5 mini, priced at $0.25 per million input tokens and $2.00 per million output tokens, that's 0.42 times $0.25 plus 0.105 times $2.00, or about $0.32 in raw token cost for the entire month. Whether you're on Copilot's free tier, Copilot Pro at $10, Cursor Hobby, or Cursor Pro at $20, the token math is noise next to the subscription price. For this profile, the flat fee IS the cost, and every vendor's marketing page is quietly written for this reader.
The daily agentic user. Twenty-one working days, three real agentic sessions a day (a feature, a bug fix, a refactor), each session running about ten turns. Because most agent harnesses resend the growing conversation transcript on every turn rather than caching it, cumulative input across one session realistically averages 200,000 tokens, with about 20,000 tokens of output (generated code plus explanation). Using GPT-5.6 Terra's current published rate of $2 per million input tokens and $12 per million output tokens, one session costs 0.2 times $2 plus 0.02 times $12, or $0.64. Sixty-three sessions a month (3 times 21) puts raw model cost at roughly $40 for the month.
Run that $40 through each billing model and the differences show up fast. Pay-as-you-go against the raw API, the bill is close to $40, scaling with whatever you actually did. On GitHub Copilot Pro+ at $39 a month with $70 of included AI Credits, that $40 of usage fits inside the pool with room left over, so the bill stays flat at $39, no overage triggered. On Cursor Pro at $20 with a $20 credit pool, the same $40 of usage roughly doubles the included amount, triggering on-demand overage billed in arrears, which is exactly where Cursor Pro+ at $60 flat starts looking better, purely for predictability. Claude Pro prices around a weekly rate limit rather than a visible credit pool, so this workload either fits or it doesn't. There's no overage invoice, you get throttled instead: a blocked session at 4pm instead of a bigger bill next month.
A team of five. Same daily-agentic-user workload, five people, no discount assumed yet. Aggregate raw model cost on a shared pay-as-you-go key: roughly $200 a month, scaling with real usage, no seat floor. Cursor's Teams Standard plan at $40 a user comes to $200 flat for five seats, close enough to the pay-as-you-go number that the Teams price isn't really a markup here, plus centralized billing and admin controls. Five individual Copilot Pro+ seats at $39 each run $195, and each $70 credit pool comfortably covers the $40-per-person workload. Five Claude Pro seats at $20 each run $100, provided nobody regularly hits the weekly limit; teams that do end up moving seats to Claude Max at $100-plus each, turning the team number into a range rather than a fixed figure. One caveat: Copilot's Business and Enterprise SKUs have their own per-seat credit allotments we could not fully confirm at write time, so the math above uses the individual Pro+ seat instead.
One line item is missing from all three profiles, deliberately, because no vendor meters it: a change that shipped broken. A retry costs a few cents of tokens. A bad merge costs a rollback, an incident thread, and an afternoon from whoever gets pulled into it. That's the cost we built Autonoma against rather than any of the ones above, which is why it never shows up in a plan comparison like this one.
Which billing model absorbs each number, flat, credits, or overage, matters more than the number itself. The dollar figures shift by plan and provider; the shape doesn't. Light usage is a fixed floor, agentic usage is where the billing model starts to matter, and team usage is the light-user math times headcount, minus whatever pooling a Teams plan gives you. Bar heights are true scale above the light-user bar, held to a visible minimum: $200 is exactly five times $40.
The Failure Modes That Cost Money
Three habits turn the numbers above into a bill nobody planned for, and none of them show up until you go looking, in any tool from our full comparison of the category.
Running a flagship model on mechanical work is the most expensive one, and the cheapest LLM cost optimization available here isn't switching vendors, it's not paying flagship rates for mechanical work. Tier-matched to Luna, Sol prices at exactly 25 times more on both input and output, at both the default and long-context tier: $5 to $0.20, $10 to $0.40, $30 to $1.20, $45 to $1.80. Route a third of the daily agentic user's 63 monthly sessions, the ones that are really just renames, mechanical edits, or boilerplate, through the flagship tier instead of the cheap one, and the $40-a-month example above climbs into the hundreds without a single extra session run.
Long sessions that keep resending context are the quiet one. The daily-agentic-user math above assumed no prompt caching, which is why 200,000 cumulative input tokens for a single ten-turn session is realistic rather than ten independent 5,000-token exchanges adding up to 50,000. If a tool or workflow doesn't engage caching, every turn re-sends the growing transcript, and that compounding is the single biggest lever between a $40 month and a $150 month for what feels like the identical routine.
Leaving auto model selection on is the invisible one. Cursor's Auto mode and Copilot's model auto-routing both exist so you don't have to pick a model every time, and both tend to reach for a stronger model when they're uncertain about the task, which is the first failure mode above, just hidden until the invoice. Check what your session used before you assume the cheap tier ran it.
All three habits share a shape: they cost money because nothing told you the cheap path had already worked. A session gets long because the last attempt went wrong and you re-explained instead of starting clean. A flagship run gets justified because you don't trust the cheap tier's output. Both are verification problems arriving disguised as billing problems, which is the reason Autonoma runs behavioral tests against the running application rather than grading the diff: a change you can confirm works is a change you stop paying to redo.
The Two-Layer Cost Structure Nobody Names
Every dollar you spend in this category sits on two independently volatile layers, and no vendor's pricing page separates them for you.
Layer one is the tool's own billing model: the subscription price, the size of the credit pool, what a credit or a premium request costs against a given model. This is the layer a vendor controls and changes on its own schedule, for its own reasons. GitHub Copilot's move from premium-request-unit billing to token-metered AI Credits on June 1, 2026 is exactly this kind of change: Pro's $10 and Pro+'s $39 sticker prices didn't move, but what a dollar of that subscription actually buys shifted, because the unit of account underneath the same plan name changed.
Layer two is the underlying provider's raw LLM API pricing, and it moves for reasons that have nothing to do with any coding tool's roadmap. CNBC reported on July 30, 2026 that OpenAI cut GPT-5.6 Luna's API pricing by 80%, from $1 and $6 per million input and output tokens down to $0.20 and $1.20, and cut GPT-5.6 Terra by 20%, from $2.50 and $15 down to $2 and $12, roughly three weeks after both models launched. GPT-5.6 Sol, the flagship tier, didn't move. OpenAI attributed the cut to efficiency gains from the model's own development. Worth noting honestly rather than overstating: Moonshot AI had shipped its open-weight Kimi K3 model earlier the same month and Anthropic answered with Claude Opus 5 shortly after, so the cut landed inside a real stretch of competitive pressure, even though the precise gap between Kimi K3's release and OpenAI's announcement isn't pinned down by either company's own statements.
Neither event touched the other layer. Copilot's billing mechanics changed and OpenAI's token prices didn't move because of it. OpenAI's token prices changed and no coding tool's subscription price moved in response, though every tool routing traffic to Luna or Terra under the hood just got a quiet margin change, depending on how much of that cut gets passed through. GitHub's own current model pricing table already reflects the post-cut Luna and Terra rates, which is about as close to independent confirmation as this category gets. A tool's pricing page can be entirely accurate the day you check it and still be wrong within weeks, not because anyone lied, but because it's describing two different moving parts and only one of them gets a visible changelog.
Three weeks apart, each event moved a different layer, not the other. Neither clock answers to the other, which is why a pricing page can be accurate the day you check it and wrong within weeks.
Pricing Verified as of August 5, 2026
Everything below is a dated snapshot, checked directly against each vendor's own page on the date above. This category has already rewritten its billing mechanics once this year and cut two of the three models in the GPT-5.6 line within about three weeks of their launch, while the flagship held steady, so re-check before you budget, not just this table. GitHub also prices each GPT-5.6 model at two tiers, a lower default rate and a higher long-context rate above a per-model token threshold, which is why the table below shows a range for all three. We refresh this block quarterly.
| Tool | Plan | Price/mo | What's included |
|---|---|---|---|
| Cursor | Pro | $20 | $20 usage credit pool |
| Cursor | Pro+ | $60 | 3x Pro's credit pool |
| GitHub Copilot | Pro | $10 | $15 in AI Credits |
| GitHub Copilot | Pro+ | $39 | $70 in AI Credits |
| Claude | Pro | $17-20 | Weekly limit, includes Claude Code CLI |
| Claude | Max | $100+ | 5x-20x Pro's rate limit |
| Model | Input $/M | Output $/M | Note |
|---|---|---|---|
| GPT-5.6 Luna | $0.20-0.40 | $1.20-1.80 | Cut 80%, Jul 30, 2026 |
| GPT-5.6 Terra | $2.00-4.00 | $12.00-18.00 | Cut 20%, Jul 30, 2026 |
| GPT-5.6 Sol | $5.00-10.00 | $30.00-45.00 | Flagship, unchanged |
| Claude Haiku 4.5 | $1.00 | $5.00 | Cheapest Claude tier |
| Claude Sonnet 4.6 | $3.00 | $15.00 | Mid-tier reasoning |
| Claude Opus 5 | $5.00 | $25.00 | Top-tier reasoning |
Subscription and credit figures checked against Cursor's pricing page, GitHub's Copilot plans page, and Claude's pricing page. Raw model rates checked against GitHub's published Copilot model pricing table, which lists the underlying LLM API pricing it bills AI Credits against. The GPT-5.6 price cut is sourced to CNBC, linked above, and the pre-cut figures it reports ($1/$6 for Luna, $2.50/$15 for Terra) match what multiple outlets independently reported the same week.
Where This Leaves You
Nothing above declares a single winner, because nobody in this category can honestly do that. Every source we checked, and every thread arguing about it, converges on developers running more than one of these tools and billing models at once, and the accurate read is that the right mix depends on how you actually work, not which vendor's homepage you opened first.
If your day is mostly autocomplete with occasional chat, the subscription floor is your real cost, so pick whichever flat plan's other features you like most, the token math won't move the number. If you run agentic sessions daily, weigh the credit-pool-to-model-tier fit before the sticker price: a $70 pool absorbing a $40 workload beats a $20 pool that doesn't, even when the smaller pool's plan costs less up front. If you're pricing a team, run the per-seat LLM cost comparison before committing to a per-user tier, and re-run it against whatever the vendor charges the week you buy, since Copilot alone rewrote its entire unit of account just over two months before this went live.
For the exact bring-your-own-key crossover point where raw tokens beat a flat Cursor subscription, turn by turn, see our Cline vs Cursor cost breakdown. For model choice inside a tool you've already picked, rather than the billing wrapper around it, see GitHub Copilot's model lineup, the best model for Cursor, and the best model for Claude Code.
None of the math above touches the cost that actually sinks a team's month: shipping a change nobody verified. A month of Cursor Ultra at $200 is a rounding error next to one bad deploy that reaches real users, and every billing model in this article optimizes for the wrong side of that tradeoff: how cheaply you can generate a change, not whether the change that shipped actually works. That's the gap Autonoma exists to close: it runs behavioral end-to-end tests against your real, running application, so a change that looked fine in the diff and cost three cents in tokens gets checked before anyone but your reviewer sees it. It isn't a line item that belongs in the tables above. It's the check that runs after whichever billing model you picked has already done its job.
Frequently Asked Questions
It depends entirely on your usage pattern, not which side of the copilot vs cursor pricing debate you started on. In our worked daily-agentic-user example, $40 of monthly raw model usage fit comfortably inside GitHub Copilot Pro+'s $70 credit pool at $39 a month, while it exceeded Cursor Pro's $20 pool at $20 a month and triggered overage billing. At lighter usage, both plans are effectively flat fees and the difference barely registers. Run your own token estimate through both plans' included pools before assuming either one is cheaper by default.
GitHub replaced Premium Request Units with token-metered AI Credits on June 1, 2026, tying cost directly to the model and the number of tokens consumed rather than a flat per-interaction count. Base subscription prices for Pro and Pro+ didn't change, but what a dollar of that subscription buys did, since the unit being metered changed underneath the same plan names.
No, and it depends heavily on volume. Our companion piece on Cline vs Cursor found the crossover sits around 35 to 40 agent turns a day: below that, bring-your-own-key raw token billing tends to cost less than a flat Cursor subscription, and above it, the flat plan usually wins. Raw tokens also carry full exposure to the LLM API pricing swings this article covers, which a subscription's credit pool partly buffers you from.
More often than most budgets assume. GitHub Copilot rewrote its entire billing mechanic in June 2026, and OpenAI repriced two models in its GPT-5.6 line by up to 80% in July 2026, three weeks after launching them. Treat any pricing figure in this category, including the ones in this article, as a dated snapshot that needs rechecking against the vendor's current page before you commit a team budget to it.
The cost of a change that shipped broken. Subscriptions, credit pools, and raw token rates all price how cheaply you can generate a diff. None of them price whether the diff works once it is running, which is the one line item measured in rollbacks and incident threads rather than dollars per million tokens. That's the gap Autonoma covers: it reads your codebase, generates behavioral end-to-end tests, and runs them against your actual running application on every pull request, so a change that cost three cents in tokens gets verified before anyone but your reviewer sees it. It sits after whichever billing model in this article you picked, not alongside them.
The best QA solution for AI coding tools is one that automatically validates what Cursor, Copilot, or Claude actually produced before it reaches production, independent of which billing model paid for it. Every pricing structure compared in this article, subscription, credit pool, or raw API tokens, measures how cheaply a change was generated. None of them measure whether the change works. Autonoma is an AI-native QA layer built for that gap: it reads your codebase, generates behavioral end-to-end tests from your real routes and flows, and runs them against your running application on every pull request, catching regressions no matter which coding assistant or pricing tier produced the diff.
