Most lists of Claude Code alternatives are written by companies selling a competing agent. This one is not — we sell nothing, and every price below was read off the vendor’s own developer documentation on 25 July 2026, not copied from another list. It covers three familiar categories (commercial IDE agents, free tiers, open-source BYOK clients) plus a fourth almost nobody writes up: keeping the Claude Code client and swapping the model behind it. We also do the arithmetic every other list skips — how many agentic tasks a month each flat plan needs before it beats that same vendor’s pay-as-you-go rate.
Quick verdict: the 12 Claude Code alternatives at a glance
| Tool | Entry price | Where it runs | Best for |
|---|---|---|---|
| Cursor | Free / $20 / $60 / $200 | Own IDE fork | Editor-first workflows, largest ecosystem |
| GitHub Copilot | Free / $10 / $39 / $100 | VS Code, JetBrains, GitHub | Teams already standardised on GitHub |
| Devin (formerly Windsurf) | Free / $20 / $200 | Own IDE + cloud agents | Delegating whole tickets to a cloud agent |
| Google Antigravity | $0 for individuals | Own client | Zero-budget access to frontier models |
| Amazon Q Developer | Free / $19 per user | IDE + AWS console | AWS-heavy shops, Java modernisation |
| Kiro | Free / $20 / $40 / $100 / $200 | Own client | Spec-driven work, credit-metered budgeting |
| Gemini CLI | Free with a Google account | Terminal | Free terminal agent with a 1M-token window |
| Aider | Free (Apache 2.0) | Terminal, BYOK | Git-native pair programming, full cost control |
| Cline | Free (open source) | VS Code, BYOK | Editor agent with no seat fee |
| OpenCode | Free (open source) | Terminal, BYOK | Terminal agent, optional pay-per-token marketplace |
| Z.ai GLM Coding Plan | $18 / $72 / $160 | Claude Code and 20+ clients | Flat-rate agent volume at the lowest published price |
| Qwen Coding Plan | $50 | Claude Code, Cursor, Codex and others | Published per-window request quotas |
Two things in that table are worth pausing on, because every competing list we checked still gets them wrong. Windsurf is no longer a standalone brand: windsurf.com/pricing now redirects to devin.ai/pricing, and the tier structure that lists still quote ($15 and $30 seats) is gone. And the Qwen Coding Plan’s cheap Lite tier is dead — Alibaba Cloud stopped accepting new Lite subscriptions on 20 March 2026 and stopped renewals and upgrades on 13 April 2026, so the roughly $10 figure that circulates in nearly every roundup can no longer be bought.
What the Claude Code alternatives actually cost
Prices below are the published list prices on each vendor’s own pricing or documentation page as of 25 July 2026.
Cursor: Hobby free, Pro $20/month, Pro+ $60/month, Ultra $200/month, Teams Standard $40/user/month, Teams Premium $120/user/month, Enterprise on request. Cursor does not publish per-tier agent request caps — the page describes higher tiers only as having larger allowances, so the request numbers are officially unpublished.
GitHub Copilot: Free ($0, 2,000 completions per month), Student free with verification, Pro $10/month, Pro+ $39/month, Max $100/month (a new tier), Business $19 per granted seat, Enterprise $39 per granted seat. Copilot has moved off “premium requests” onto AI Credits. GitHub’s plans page does not state annual prices or the credit allowance per tier, so both are officially unpublished on that page.
Devin (formerly Windsurf): Free $0, Pro $20/month, Max $200/month, Teams at an $80/month team fee plus $40/month per full developer seat, Enterprise via sales. Pro and above include frontier models from OpenAI, Anthropic and Google, unmetered use of Cognition’s own SWE model and open-source models, and cloud agents, with overage available at API rates.
Google Antigravity: the individual tier is $0/month with no subscription, and it includes Gemini 3.5 Flash, Gemini 3.1 Pro, Gemini 3 Flash, Claude Sonnet and Opus 4.6, and gpt-oss-120b, plus unlimited tab completions and unlimited command requests. Google AI Pro and Google AI Ultra tiers exist above it — but the pricing page publishes no price for either, and no numeric rate limit for any tier, describing them only as basic or more generous weekly limits. That is a real gap, and we are not going to fill it with a number from a blog.
Amazon Q Developer: Free gives 50 agentic requests and 1,000 lines of Java upgrade per month; Pro is $19/user/month with 4,000 lines/user/month of Java transformation pooled at the account level and $0.003 per extra line. The Pro tier’s agentic request ceiling is officially unpublished. Sibling product Kiro is credit-metered and clean about it: Free 50 credits, Pro $20/1,000, Pro+ $40/2,000, Pro Max $100/5,000, Power $200/10,000, with Team tiers at identical price and credit levels plus SSO, analytics and org management.
Gemini CLI: signing in with a Google account gives 60 requests per minute and 1,000 requests per day against Gemini 3 models with a 1M-token context; an API key gives 1,000 requests per day. The paid routes are a metered API key, Vertex AI, or a Gemini Code Assist licence — the repository does not price them, so those are officially unpublished.
Open source and bring-your-own-key: Aider is Apache 2.0 licensed and free, you pay only your model provider. Cline’s open-source version carries no subscription or seat fee; its Enterprise tier is priced “Custom”, i.e. unpublished. OpenCode is open source, and its OpenCode Zen model marketplace is explicitly optional — you can run OpenCode entirely on your own keys. Zen itself offers several free models and paid ones from $0.14 to $30 per million input tokens, auto-reloading $20 when the balance drops below $5, with a 4.4% + $0.30 card fee. We could not retrieve a citable official page for Continue.dev this round, so we publish no figures for it rather than guess.
The fourth category: keep Claude Code, swap the model behind it
Here is the option the other roundups leave out. Claude Code reads ANTHROPIC_BASE_URL and an auth token from the environment. Several labs run an Anthropic-compatible endpoint and document, on their own sites, exactly how to point Claude Code at it. You keep the client, the keybindings, the agent loop and the tooling; only the model changes.
Z.ai is the most explicit. Its developer documentation lists Claude Code among 20-plus supported tools and gives the configuration directly: set ANTHROPIC_BASE_URL to https://api.z.ai/api/anthropic, set ANTHROPIC_AUTH_TOKEN to your Z.ai key, and map the model names — ANTHROPIC_DEFAULT_SONNET_MODEL and ANTHROPIC_DEFAULT_OPUS_MODEL to glm-5.2, ANTHROPIC_DEFAULT_HAIKU_MODEL to glm-4.7. The GLM Coding Plan runs $18/month for Lite, $72 for Pro and $160 for Max, discounted 30% on annual billing to $12.60, $50.40 and $112 per month. Z.ai publishes quotas — roughly 80 prompts per five-hour window and 400 per week on Lite, 400 and 2,000 on Pro, 1,600 and 8,000 on Max — while stating itself that these are estimates that vary with project complexity, repository size and whether auto-accept is on. (Correction, 4 September 2026: these prompt-based quotas describe the plan Z.ai withdrew from sale on 30 July 2026 and now labels a legacy plan. New subscribers get credits instead — see the correction at the end of this article.)
Alibaba Cloud’s Qwen Coding Plan lists Claude Code among its compatible clients too, alongside Qwen Code, Cline, Cursor and Codex. Pro is $50/month with published quotas of 6,000 requests per five hours, 45,000 per week and 90,000 per month. Notably, the plan serves not only Qwen models but also kimi-k2.5, glm-5 and MiniMax-M2.5 — one subscription, several labs.
MiniMax’s Token Plan is $20 (Plus), $50 (Max) and $120 (Ultra) per month, each described by concurrent agent counts (3–4, 4–5, 6–7) over rolling five-hour and weekly windows covering every model on the platform. MiniMax does not publish the request or token count inside those windows — officially unpublished. Credits top up overflow at 1,000 credits per dollar with 365-day validity.
Moonshot’s Kimi Code Plan publishes only CNY pricing, even on the English page: ¥39/month (Andante), ¥79 (Moderato), ¥159 (Allegretto) and ¥559 (Allegro), with K3 and its 1M-token context from Moderato up. There is no official USD price, so we are not going to convert one and present it as official. Kimi also does not state on that page whether Claude Code is a supported client — it documents its own CLI.
The part every tutorial omits
Anthropic’s own Claude Code documentation addresses third-party gateways directly, and it is not a neutral statement. Anthropic writes that it neither endorses, maintains nor audits third-party gateway products, and that it “doesn’t support routing Claude Code to non-Claude models through any gateway” (Anthropic, Claude Code LLM gateway docs).
The same page carries a second consequence people discover the expensive way: once a gateway credential variable or an apiKeyHelper is active, your claude.ai subscription is no longer the credential in play. It does not top up or fall back — the subscription’s usage limits stop applying and traffic bills per token to whoever owns the credential. Setting ANTHROPIC_BASE_URL alone, without a credential, does not displace the subscription.
So the honest framing is: this works, the vendors document it, and it is materially cheaper — and it is explicitly outside the support envelope of the company that makes the client. If your team needs a vendor to escalate to when the agent misbehaves, that matters more than the price difference. If you are an individual optimising cost, it may not.
The break-even math: when a flat plan beats paying per token
Almost every list of Claude Code alternatives stops at the sticker price. The more useful question is how much work a plan has to absorb before it beats the same vendor’s own metered API. We modelled one “task-unit” as a realistic feature-sized agentic run: 250,000 input tokens with 80% cache hits, 25,000 output tokens. Then we divided each plan’s monthly price by the API cost of one task-unit on that vendor’s own comparable model. This is pure arithmetic on published rates — no assumptions about quality, and no cross-vendor claims.
| Plan | Monthly price | Tasks/month to break even | Per working day |
|---|---|---|---|
| Claude Pro (Opus 5) | $20 | 15.8 | 0.8 |
| Codex Plus | $20 | 18.2 | 0.9 |
| Kimi Andante | ¥39 | 32.0 | 1.5 |
| Claude Pro (Sonnet 5 promo) | $20 | 39.4 | 1.9 |
| GLM Coding Lite (annual) | $12.60 | 54.3 | 2.6 |
| Kimi Moderato | ¥79 | 64.8 | 3.1 |
| Qwen Coding Plan Pro | $50 | 74.1 | 3.5 |
| GLM Coding Lite | $18 | 77.6 | 3.7 |
| Claude Max 5x | $100 | 78.9 | 3.8 |
| Codex Pro (from) | $100 | 90.9 | 4.3 |
| Kimi Allegretto | ¥159 | 130.3 | 6.2 |
| Claude Max 20x | $200 | 157.8 | 7.5 |
| GLM Coding Pro | $72 | 310.3 | 14.8 |
| MiniMax Token Plus | $20 | 350.9 | 16.7 |
| Kimi Allegro | ¥559 | 458.2 | 21.8 |
| GLM Coding Max | $160 | 689.7 | 32.8 |
| MiniMax Token Max | $50 | 877.2 | 41.8 |
| MiniMax Token Ultra | $120 | 2,105.3 | 100.3 |
Kimi rows are computed entirely in CNY — plan price in CNY against Kimi’s own CNY token rates — because there is no official USD price to convert from.
Read that table carefully, because it inverts the usual intuition. A plan looks better the lower its break-even number, and cheap-model plans have terrible break-evens against their own APIs precisely because the underlying tokens are so cheap. MiniMax Token Ultra at $120 needs about 2,105 task-units a month — roughly 100 agentic tasks every working day — before it beats simply paying MiniMax per token. That is not a criticism of the model; it is an argument that for MiniMax you should probably just use the API. Conversely, Claude Pro at $20 breaks even at under one task a day against Opus 5 rates, which nearly any full-time developer clears, which is exactly why the $20 Anthropic tier is such an efficient purchase.
Where a vendor publishes an actual quota we can do better than a break-even and compute a ceiling price per task. Treating one task-unit as roughly 25 agent prompts — that ratio is our own working assumption, not a vendor figure — GLM Coding Lite’s 400 prompts/week — a legacy-plan figure, see the correction below — works out near $0.26 per task-unit, GLM Pro near $0.21, GLM Max near $0.12, and Qwen Pro’s 90,000 monthly requests near $0.014. Compare that with roughly $1.27 per task-unit on Claude Opus 5 and $1.10 on GPT-5.6 Sol at list API rates, and the size of the gap is clear.
The uncomfortable corollary: only about half of the twelve options publish enough to compute any of this. Cursor, Copilot, Kiro and Antigravity meter in credits or unstated allowances, so no honest break-even exists for them. That is a fact about their disclosure, and it belongs in the comparison.
Why we are not ranking these on benchmark scores
You will find lists that put all twelve Claude Code alternatives in one table with a SWE-bench column. We will not, and the reason is methodological rather than coy. These are clients, not models — Cursor, Cline and Aider have no score of their own because they run whatever model you point them at. Where the underlying labs do publish scores, they publish them under different scaffolds, different attempt budgets, different subsets and different dates; lining them up in one column produces a number that looks precise and means very little. Anthropic, for its part, publishes its most recent agentic-coding tables as images rather than citable text, so there is no clean figure to quote for the current Claude models at all.
The practical substitute is boring and reliable: run the same three real tickets from your own repository through two candidates on their free tiers, and read the diffs. That measurement is about your codebase, which is the only comparison that changes your decision.
Context, quotas and the things that actually bite
Beyond price, three operational details separate these Claude Code alternatives in daily use.
Quota shape matters more than quota size. Z.ai, Qwen and MiniMax all meter on rolling five-hour windows in addition to weekly ones. A five-hour window punishes bursty work — the exact pattern of a developer who batches an afternoon of agent runs — in a way a monthly cap does not. Qwen’s 6,000 requests per five hours is generous enough that most individuals will never see it; GLM Lite’s roughly 80 prompts per five hours is a real ceiling for a heavy session. (Correction, 4 September 2026: legacy-plan figure; the current Lite ceiling is 2,000 credits per five hours.)
Context windows are advertised, not guaranteed in practice. Gemini CLI’s free tier carries a 1M-token window, and Kimi’s K3 is advertised at up to 1M from the Moderato tier up. Those are large enough that the binding constraint usually becomes the agent’s own retrieval strategy rather than the window.
Free is genuinely free in two cases. Google Antigravity gives individuals frontier models, including Claude Sonnet and Opus 4.6, at $0, and Gemini CLI gives 1,000 requests a day against Gemini 3 for a Google login. Neither asks for a card. The catch in both is undisclosed rate limiting, which is a fair trade at that price but not something to build a team’s workflow on.
Who should choose what
If you want the cheapest credible full-time agent, take the GLM Coding Plan Lite at $18 (or $12.60 annually) and run it through Claude Code — accepting that Anthropic does not support that configuration.
If you want maximum agent volume per dollar with published quotas, Qwen Coding Plan Pro at $50 publishes 90,000 requests a month, which is the most transparent allowance in this comparison.
If you are budget-constrained to zero, use Google Antigravity for frontier models in a full client, or Gemini CLI in the terminal.
If you want total cost control and no lock-in, use Aider, Cline or OpenCode with your own key and pay only for tokens — this is also the only path where the per-task cost model above maps exactly onto your bill.
If you are an enterprise that needs someone to escalate to, stay with a supported commercial path: Copilot Business at $19 per seat, Cursor Teams, Devin Teams, or Claude Code itself. The gateway trick saves real money and costs you your support relationship.
If you already pay Anthropic $20 and are deciding whether to leave, look at the break-even table again. Claude Pro clears its own break-even at under one task per day. The reason to switch is a quota ceiling or a model preference — not price.
For the model layer underneath these clients, see our AI coding models compared hub. For the head-to-head that started this cluster, see Codex vs Claude Code, and for the full cost picture across subscription tiers see AI coding assistant pricing in 2026.
Read next
- Claude Code vs Cursor: what each plan actually buys
- Claude Code vs GitHub Copilot: credits, limits and real cost
- Is Claude Code free? The short answer and the real cost
FAQ: Claude Code alternatives
What is the best free alternative to Claude Code?
Google Antigravity’s individual tier is the strongest free option: $0 per month with no subscription, and it includes Gemini 3.5 Flash, Gemini 3.1 Pro, Claude Sonnet and Opus 4.6 and gpt-oss-120b, plus unlimited tab completions and command requests. Gemini CLI is the best free terminal option at 60 requests per minute and 1,000 per day with a Google account. Both apply weekly rate limits that Google does not publish as numbers, so plan around unpredictability rather than a stated ceiling.
Can I use Claude Code with GLM, Qwen or another non-Anthropic model?
Technically yes, and the vendors document it. Z.ai publishes the exact Claude Code configuration for its GLM Coding Plan, and Alibaba Cloud lists Claude Code among the compatible clients for the Qwen Coding Plan. But Anthropic’s own documentation states it does not support routing Claude Code to non-Claude models through any gateway, and does not endorse, maintain or audit those gateways. It also warns that once a gateway credential is active your claude.ai subscription stops being the credential in use — subscription limits no longer apply and usage bills per token instead.
Which Claude Code alternative is cheapest for heavy daily use?
By published price per unit of work, the Z.ai GLM Coding Plan is the cheapest flat plan that runs in a Claude Code client — $18 per month, or $12.60 on annual billing, for roughly 400 prompts a week. Alibaba’s Qwen Coding Plan Pro at $50 publishes the largest allowance at 90,000 requests per month. If you would rather pay per token, the open-source clients — Aider, Cline, OpenCode — cost nothing themselves and let you route to whichever model is cheapest that month.
Is Windsurf still available as a Claude Code alternative?
Not under that name. The windsurf.com pricing page now redirects to devin.ai/pricing, and the product is sold under Cognition’s Devin branding: Free at $0, Pro at $20 per month, a new Max tier at $200, Teams at an $80 monthly team fee plus $40 per full developer seat, and Enterprise via sales. Any roundup still quoting Windsurf at $15 or $30 per seat is describing a price structure that no longer exists.
How many tasks per month do I need before a subscription beats the API?
It depends on how expensive the underlying tokens are, and the answer is counter-intuitive. On our model of a feature-sized task — 250,000 input tokens at 80% cache hit rate and 25,000 output tokens — Claude Pro at $20 breaks even at about 16 tasks a month against Opus 5 rates, under one per working day. Codex Plus breaks even at about 18. But cheap-token plans need enormous volume: GLM Coding Lite needs about 78 tasks a month, and MiniMax Token Ultra needs roughly 2,105, or 100 every working day. Below those thresholds you are better off on that vendor’s own metered API.
Related: Claude Max vs ChatGPT Pro: what 5x and 20x actually mean — what the tier multipliers do and do not cover before you switch tools.
Update, 30 August 2026: the GLM swap-the-engine option has changed shape
The “keep Claude Code, swap the model behind it” category above is still the cheapest route on this page, but Z.ai has rebuilt the plan that makes it work. As read from docs.z.ai on 30 August 2026, the GLM Coding Plan now meters in credits rather than prompts (Lite 2,000 per five-hour window and 10,000 per week; Pro 12,000 / 60,000; Max 28,000 / 140,000), serves only GLM-5.3 and GLM-5.3-Flash, and applies a 50% off-peak credit rate outside Monday–Friday 14:00–18:00 Singapore time. By our arithmetic that peak window is 02:00–06:00 US Eastern, so a North American developer working normal hours is off-peak effectively all the time and gets roughly double the token allowance the posted credit numbers imply.
Two constraints worth knowing before you commit: the plan is contractually limited to officially supported tools (Claude Code, Cline, OpenCode among them), and Claude Code must be pointed at https://api.z.ai/api/anthropic or calls fail with an “insufficient balance” error despite an active subscription. Full worked arithmetic on both sides, including where Anthropic is actually the cheaper option, is on GLM Coding Plan vs Claude Code.
Correction and update, 4 September 2026: the GLM quotas above describe a withdrawn plan
The GLM Coding Plan figures used earlier on this page — roughly 80 prompts per five-hour window and 400 per week on Lite, 400 and 2,000 on Pro, 1,600 and 8,000 on Max — were correct when written, but they are no longer the plan on sale. Z.ai’s Plan Update Announcement, published 30 July 2026, states that the GLM Coding Plan moved to a credits-based system and that the earlier plans “are no longer sold to new users.” Those prompt figures now appear on Z.ai’s own site under a heading it labels “Usage Reference for Legacy Plans.” Subscriptions bought before 30 July were grandfathered and keep their old calculation method until the end of the current billing cycle.
What a new subscriber gets instead, per Z.ai’s official documentation read 4 September 2026:
| Tier | Credits per 5 hours | Credits per week |
|---|---|---|
| Lite ($18/mo) | 2,000 | 10,000 |
| Pro | 12,000 | 60,000 |
| Max | 28,000 | 140,000 |
Z.ai publishes no conversion between prompts and credits, so the per-task-unit costs derived earlier on this page cannot simply be carried across — they were built on the prompt figures, and we are not going to invent an exchange rate to rescue them. Treat the GLM rows above as describing the legacy plan until we rebuild them on the credit basis.
Credits are consumed by a published formula rather than by prompt count: for GLM-5.3 the multipliers are 6.9 for input tokens, 1.7 for cached input and 24 for output, all divided by 10,000, with model usage charged at 50% of the standard rate outside peak hours (Monday to Friday, 14:00–18:00 Singapore time). We work through what that means in dollars, and why a credit is worth three different amounts depending on what you spend it on, in GLM Coding Plan vs Claude Code: what each actually costs. The broader price table for this category is in what AI coding assistants actually cost.
Update, 18 September 2026: free and free-for-now are different budget inputs, and Google’s agent sandbox is the second kind
Token prices get all the attention when people compare alternatives, but an agent that runs code also burns machine time, and the two vendors charge for that in ways that are hard to put in the same column. Reading Google’s Gemini API pricing page on 18 September 2026, two lines stand out. On code execution:
Costs are determined solely by the tool’s usage, no charges are accrued for the session runtime.
And on managed agents, covering the Antigravity Agent environment:
Environment compute (CPU, memory, sandbox execution) is not billed during the preview period.
Anthropic charges for both. Its code execution tool is billed at $0.05 per container-hour with 1,550 hours included free each month, and its Managed Agents product is billed at $0.08 per session-hour. Put like that, Google looks free and Anthropic looks metered, and most comparisons would stop there. Work the numbers and the difference turns out not to be about price at all.
For most teams, Anthropic’s metered runtime is also zero
Our arithmetic on Anthropic’s published figures: 1,550 included hours at $0.05 is $77.50 per month of allowance before you pay anything. A single container running continuously through a 30-day month consumes 720 hours. Two containers running around the clock for an entire month is 1,440 hours — still inside the free allowance. Unless you are running three or more permanently-on sandboxes, Anthropic’s container bill is also zero.
So the honest comparison is not $0.05 against nothing. It is a standing allowance with a published number against a preview period with no published end date. Those are not the same kind of fact and they do not belong in the same cell of a comparison table, which is exactly why they usually end up there.
The same page, the same week, opposite disclosure
Here is what makes this worth writing down rather than filing as a footnote. On one page, read on a single day, Google tells you:
- A price increase with an exact date. Flash token prices double on 1 January 2027, stated six times over in the same table. That is 105 days of notice (our arithmetic).
- A free period with no date at all. Sandbox compute is not billed during the preview period, and the page does not say when that period ends or what the price becomes.
Both are honest. Neither is hidden. But they land in a budget very differently: the first is a line item you can plan, and the second is an unpriced liability that converts to a real number on a date you will find out about later. When you are choosing an alternative on cost, the unpriced item is the one that decides whether the choice survives next year — and it is the one that never appears in a comparison table, because there is no number to put in the cell.
The practical rule we would draw from this: when a vendor writes free, check whether it is an allowance or a preview. An allowance has a quantity attached to it. A preview has a tense attached to it.
Grounding and tool calls are priced per request, and the older generation costs more
The rest of Google’s tool pricing, read the same day, is per-request rather than per-token — a different unit that will not show up in any per-million comparison you have seen:
| Tool | Included free | Then |
|---|---|---|
| Google Search grounding, Gemini 3 series | 5,000 search requests per month | $14 per 1,000 requests |
| Google Search grounding, Gemini 2.5 series | Not stated on the page | $35 per 1,000 grounded prompts |
| Maps grounding, Pro | 10,000 requests per day | $25 per 1,000 |
| Maps grounding, Flash series | 1,500 requests per day | $25 per 1,000 |
The older generation is 2.5 times the price (our arithmetic, $35 against $14). That is the third place on this vendor’s own rate card where staying on an older model costs more rather than less. The first is Gemini 3.5 Flash at $1.50 / $9.00 against 3.8 Flash’s current $0.75 / $3.75. The second arrives on 1 January 2027, when 3.8 Flash input rises to $1.50 and the newer model’s input advantage over 3.5 Flash does not shrink but disappears.
This matters for anyone evaluating alternatives, because pinning an older model is usually framed as the cautious, cost-controlled decision — you avoid a migration, you avoid a regression, you keep the bill flat. On this rate card it is the expensive decision in three separate places, and the pricing page never says so, because a pricing page lists prices one model at a time and the comparison across generations is left to you.
We worked through the full token-price picture, including the January increase and what it does to the gap against Claude Sonnet 5, in our AI coding assistant pricing breakdown. The separate threshold problem — Gemini 3.1 Pro charging double above a 200,000-token prompt, and why its 1.5x output concession is worth almost nothing to a coding agent — is in our piece on context windows and what long prompts cost. For the wider field of models rather than these two vendors, see our comparison of AI coding models.
Officially not published: when the Antigravity preview period ends, what sandbox compute will cost afterwards, and the release dates of the models above. Google’s page also states that prices may differ from those listed and from those offered on Gemini Enterprise Agent Platform, so an enterprise contract may not match any figure here. We are not estimating any of these from third-party sources.
Update, 21 September 2026: the cheapest alternative is often a rung on the ladder you are already standing on
This page is organised around switching vendors. There is a cheaper kind of alternative that almost never gets counted as one, and Z.ai published a clean example of it. Read verbatim from Z.ai documentation on 21 September 2026, per million tokens, in the order input / cached input / output: GLM-5.3-Flash is $0.15 / $0.03 / $0.50, GLM-5.3-FlashX is $0.37 / $0.075 / $1.25, and GLM-5.3 is $1.4 / $0.26 / $4.4.
GLM-5.3-FlashX is new to our records rather than necessarily new to the market. We had not listed it before today. Whether it is a recent addition is officially not published, and we are not going to date a launch from a gap in our own filing.
The ladder was designed as a multiplier, and you can see the rounding
Divide each rung by the one below it. The following is our arithmetic. FlashX against Flash: 2.4667x on input, 2.50x on cached input, 2.50x on output. GLM-5.3 against FlashX: 3.784x, 3.467x, 3.52x. GLM-5.3 against Flash, end to end: 9.333x, 8.667x, 8.80x.
The interesting figure is the one that does not fit. Two of the three FlashX-over-Flash ratios are exactly 2.50. The third is 2.4667, and the reason is visible: 2.5 times $0.15 is $0.375, and the published input price is $0.37. The middle rung was set at two and a half times the bottom rung and then the input price was truncated to two decimal places.
That is a small detail with a real planning consequence. When a product line is designed as a fixed multiplier rather than priced model by model, the question how much does dropping one rung save has a single answer for the whole line, roughly 2.5x here, and you can compute it once. On a line where each model was priced independently, the saving differs at every rung and has to be recomputed for each workload. Knowing which kind of line you are on tells you how much cost modelling you actually need to do.
Why an in-family swap is a better alternative than it looks
Switching vendors carries costs that never appear in a price comparison: a different API surface, different caching semantics, different tool-calling conventions, a different tokenizer, a fresh round of evaluation, and a second vendor relationship to maintain. Moving down a rung inside one family carries almost none of those. Same endpoint, same tokenizer, same cache behaviour, same billing page. The only thing that changes is capability, which is exactly the thing you were going to have to evaluate anyway.
And the saving available from the in-family move is large. End to end on this line it is 9.33x on input and 8.80x on output. That is a bigger multiple than most vendor-to-vendor comparisons produce, obtained without leaving the vendor. If you are on this page because a bill got uncomfortable, the first experiment to run is not a competitor. It is the rung below you, on the subset of your traffic that does not need the top model.
One number that looks like a contradiction and is not
Our GLM coding plan comparison worked out that on the published weekly token allowance table, choosing the cheaper model is worth roughly 3.04x. Here the same downgrade appears to be worth 9.33x. Both are correct, and the gap between them is the point.
The 3.04x figure comes from a subscription allowance expressed in tokens per week, where the credit multipliers govern how fast you consume a fixed budget. The 9.33x figure comes from per-token API list prices, where you pay for what you use. The same engineering decision, run one rung down, is worth a different amount of money depending on which commercial surface you bought through. That is the clearest argument we have for why subscription allowances and API rate cards must never be merged into a single comparison table, a point we develop on our Claude Code context window page.
The caveat that voids the whole thing
A 9.33x saving is 9.33x only if the cheaper rung does the job in the same number of attempts. If the smaller model needs three passes where the larger needed one, the saving is 3.11x. If it needs ten, you have paid more and waited longer. Cheaper tokens are not cheaper work, and on coding tasks the retry count is the variable that decides everything. The honest way to run this experiment is to route a slice of real traffic, count retries, and compare total cost per completed task rather than cost per million tokens.
Two further limits. These prices are not comparable to another vendor per token: Anthropic states its tokenizer produces approximately 30% more tokens for the same text, so a ratio computed inside one family cannot be carried across to a competitor. And the cached input column here is currently distorted by a promotion, since Cached Input Storage is marked Limited-time Free across this line, with no published end date. We wrote up on our pricing breakdown what that free storage does to a cross-vendor cache comparison, and it is not a small effect.
All prices in this section are vendor list prices read verbatim on 21 September 2026. Ratios and totals are our arithmetic on those published numbers.
Update, 25 September 2026: the cheapest alternative on this page already has its price increase on the calendar, and there is no setting you can change to avoid it
Everything above treats Gemini 3.8 Flash as the cheap end of the list. That is correct today and it has a published expiry. Google’s pricing page, read this morning, carries both halves of the change in the same cell. Per million tokens:
| Gemini 3.8 Flash, standard tier | Through 31 Dec 2026 | From 1 Jan 2027 | Change |
|---|---|---|---|
| Input | $0.75 | $1.50 | 2.00× |
| Output | $3.75 | $7.50 | 2.00× |
| Cache hit | $0.075 | $0.15 | 2.00× |
| Cache storage, per 1M per hour | $0.50 | $1.00 | 2.00× |
That is 98 days from the date of this update. It is also, as far as we can tell, the only price rise any vendor we track has published in advance with a date attached rather than announced on the morning it happened.
The detail that matters is the fourth row: cache storage doubles too
When a per-token price goes up, the normal response is to optimise — cache harder, keep prompts warm, reuse context. That works because the optimisation is usually priced independently of the thing you are optimising away from.
Here it is not. Input, output, cache hits and cache storage all move by exactly 2.00×, so every ratio inside the card is identical on 1 January to what it is today (our arithmetic on the official numbers). A heavily cached workload doubles. A naive workload doubles. The break-even points between caching and re-sending are unchanged, which means the configuration you would pick after the increase is the same configuration you would pick before it.
Stated plainly, because it is the part that is useful and the part nobody writes: there is no change you can make to your setup that makes January cheaper. The only levers left are sending fewer tokens or sending them somewhere else. That is a genuinely unusual property of this increase and it is visible only if you read the whole card rather than the headline input price.
One honest gap: our reading captured the post-January figures for the standard tier and for cache storage. The Batch and Flex tiers are listed at $0.375 / $1.875 and Priority at $1.35 / $6.75 — respectively 0.50× and 1.80× the current standard rate (our arithmetic) — but whether those two tiers also double on 1 January is officially not stated in what we read. It would be natural to assume they track the standard tier. We are not assuming it in print.
Your per-task cost may move by more than 2.00×, and the vendor said so — on a different page
Google’s launch post for 3.8 Flash contains this about the model’s behaviour:
might use more tokens to maximize performanceThat is a vendor statement about token consumption, published on a blog. The doubling is a vendor statement about token price, published on a pricing page. Your bill is the product of the two, and the two live in different documents that are never read together. A 2.00× price change on a model that may spend more tokens than its predecessor is not a 2.00× cost change per task — it is at least that, by an amount neither page quantifies.
We are not going to put a number on “might use more tokens”. That figure is officially not published, and the only way to get it is to run your own workload on both models and compare token counts on your own traffic. If you are going to do that, do it before 31 December, while the cheap rate is still paying for the experiment.
Against the incumbent: the gap halves, and the long-context cliff is the part that actually decides it
Measured against Anthropic’s Claude Sonnet 5 at $2.00 input / $10.00 output / $0.20 cache hit, all read this morning:
- Today, 3.8 Flash is 0.375× Sonnet 5 on input, output and cache hits alike (our arithmetic).
- From 1 January it is 0.75× on all three (our arithmetic). Still cheaper, by a margin that has stopped being the reason you chose it.
Before you carry those ratios anywhere: Anthropic states its newer models use a tokeniser producing “approximately 30% more tokens” for the same text. A 0.75× per-token ratio across that boundary is not a 0.75× cost ratio, and we will not pretend otherwise. Every cross-vendor per-token comparison on this site carries that warning.
The bigger point for a page about alternatives is not the headline rate at all. Google’s own Gemini 3.1 Pro Preview is priced in two bands: $2.00 / $12.00 at or below 200k tokens, and $4.00 / $18.00 above it — a step of 2.00× on input and 1.50× on output that fires on a single token crossing a threshold (our arithmetic on the official bands). Anthropic’s pricing page, by contrast, states outright:
A 900k-token request is billed at the same per-token rate as a 9k-token requestSo the cheap alternative has a context-length cliff and the expensive incumbent has publicly promised it does not. Above 200k, Gemini 3.1 Pro’s $4.00 input is double Sonnet 5’s $2.00 and matches Claude Opus 5.5’s $4.00 exactly — before the tokeniser adjustment cuts the other way. Long-context agent work is precisely the workload people move to a cheap alternative for, and it is the workload where the price advantage is smallest or reversed. The list rate you compared on is a rate for short requests.
Correction, 25 September 2026: the generation names in the free-tier section above are stale
The free-tier listings earlier on this page name Claude Opus 4.6 four times. Anthropic’s current published lineup, on the pricing page we read every morning, is Claude Opus 5.5 at $4.00 / $20.00 and Claude Sonnet 5 at $2.00 / $10.00, with Claude Haiku 4.5 at $1.00 / $5.00. We are leaving the original text in place rather than silently rewriting it, and noting here that the generation name is out of date.
What we are not doing is telling you which model those free tiers serve today. We did not re-verify Google’s or any third party’s free-tier documentation for this update, and free tiers change their model roster more often than paid ones. Treat every model name in a free-tier listing — on this page or anywhere else — as a snapshot with no expiry date printed on it.
This keeps happening for a structural reason worth naming. A comparison page ages in two different ways. Prices age loudly: a wrong number is checkable and someone tells you. Model names age quietly. A page naming last generation’s flagship is not factually false about anything — it is simply describing a world that has moved, and there is no signal that fires when it does. We now count generation names as part of our own accuracy sweep for exactly that reason.
What to do before 31 December
- Run the token-count comparison now, not in January. If you are weighing 3.8 Flash against anything, the experiment is 2.00× cheaper to run this quarter than next, and the number you need — how many tokens it spends on your work — is the one number no vendor publishes.
- Check where your requests actually sit relative to 200k tokens. If a meaningful share of your agent runs cross that line, the band above the cliff is the price you are really paying, and the comparison you made on the headline rate was the wrong comparison.
- Do not restructure your caching in response to the increase. Every ratio in the card is unchanged; the optimal configuration on 1 January is the one you already have.
- Put 1 January 2027 in the calendar as a re-comparison, not as a migration. A 0.75× ratio to the incumbent is still cheaper — it is just no longer a margin that survives a tokeniser adjustment untouched.
- Archive the paragraph, not the table. The wording “through December 31, 2026” is prose on a pricing page, and prose on pricing pages is the thing that disappears without a changelog. Copy it into your own notes with today’s date.
Read next: the full cross-vendor rate card on our AI coding assistant pricing page; running Claude Code on someone else’s subscription, where four vendors now sell a plan and each one uses a different billing denominator; and Codex versus Claude Code, which carries the other dated deadline currently in play — 14 October 2026.