Codex vs Claude Code is the wrong question if you ask it as “which is better.” Asked as “which one will cost me less for the way I actually work, and which one fails in a way I can live with,” it has a real answer. This comparison is dated July 2026 and covers GPT-5.6 (released July 9), which none of the currently-ranking comparisons include. Every price and benchmark number below carries its official source, and where a vendor has not published a number, we say so instead of guessing — which turns out to matter more than you’d expect. For the wider field beyond these two, start with our best AI coding models compared.
What changed in July 2026
Most comparison articles you’ll find were written between February and June 2026 and are one to three model generations stale. Here is what moved this month.
OpenAI shipped GPT-5.6 on July 9, 2026, in three variants — Sol, Terra, and Luna — all with a 1,050,000-token context window (OpenAI model docs). Sol is the frontier variant, priced at $5.00 input / $0.50 cached input / $30.00 output per million tokens (GPT-5.6 Sol model page).
There is an important caveat nobody else is reporting: GPT-5.6 is confirmed for ChatGPT, but not yet listed anywhere in Codex. OpenAI’s help center states availability as “Terra for Free and Go; Sol, Terra, and Luna for Plus, Pro, Business, and Enterprise” (GPT-5.6 in ChatGPT) — but that page is about ChatGPT. The Codex pricing page and the Codex rate card contain no GPT-5.6 row at all as of this writing. If you’re buying a Codex plan specifically to get GPT-5.6, verify it in your own account first.
On the Anthropic side, Claude Opus 5 is the current frontier model with a 1M-token context window and 128k max output (Claude models overview). Claude Code’s 5-hour rate limits were doubled for Pro, Max, Team, and Enterprise, and the peak-hours reduction on Pro/Max was removed (Anthropic announcement).
Quick Verdict
If you want one sentence: Codex is cheaper and more predictable; Claude Code is more capable per session and more expensive per token — and the gap is mostly about how each one spends tokens, not which model is smarter.
| Dimension | OpenAI Codex | Claude Code |
|---|---|---|
| Entry paid tier | $8/mo (Go) | $20/mo (Pro) |
| Mainstream tier | $20/mo (Plus) | $20/mo (Pro) |
| Power tier | From $100/mo (Pro, 5x or 20x) | $100/mo (Max 5x) · $200/mo (Max 20x) |
| Team seat | $25/mo monthly, $20/mo annual | $20–25 (Standard) · $100–125 (Premium) |
| Frontier context window | 1,050,000 (GPT-5.5 / 5.4 / 5.6) | 1,000,000 (Opus 5 / Sonnet 5 / Fable 5) |
| Frontier API price (in/out per 1M) | $5.00 / $30.00 (GPT-5.6 Sol) | $5.00 / $25.00 (Opus 5) |
| Cheapest capable API option | GPT-5.4-mini (18.75 / 113 credits) | Sonnet 5 at $2 / $10 (introductory rate, now the standard price) |
| Vendor’s own monthly cost estimate | ~$100–200 per developer | ~$150–250 per developer |
| Official agentic coding scores | Published, extensive | Not published as text — see below |
| Usage-limit transparency | Message ranges published per tier | Absolute limits never published |
Sources: Codex pricing · Codex rate card · Claude pricing · Claude API pricing · Claude Code costs
Codex vs Claude Code: what you’ll actually pay per month
This is the section every other comparison skips. Nine ranking articles were checked; none of them model a monthly bill. They list subscription prices and API rates side by side and leave you to do the arithmetic — which is exactly where the decision actually lives.
Two anchors make this modelable, and both come from the vendors themselves:
- Anthropic publishes that Claude Code runs about $13 per developer per active day, or $150–250 per developer per month, with 90% of users staying under $30 per active day (Claude Code costs).
- OpenAI publishes an estimate of ~$100–200 per developer per month for Codex (Codex rate card), where a typical GPT-5.5 task consumes 5–45 credits.
Note that both of those figures exceed the $20 mainstream subscription by a wide margin. That is the single most useful fact in this entire comparison: for a working professional, the $20 tier is not the real price of either tool. It is the price of a trial.
Cost by persona
On sticker price Codex is cheaper or tied at every persona below full-time use; Claude Code wins outright only for overnight batch work, where the Batch API cuts Sonnet 5 to $1 per 1M input and $5 per 1M output.
| Persona | Codex: cheapest sane setup | Claude Code: cheapest sane setup | Who wins |
|---|---|---|---|
| Hobbyist, a few hours a week | Go $8/mo | Pro $20/mo (or $17 annual) | Codex — there is no $8 equivalent on the Claude side |
| Solo dev, ~2 hrs/day | Plus $20/mo, occasional credit top-ups | Pro $20/mo, will hit the 5-hour window on heavy days | Tie on price; Codex has more headroom at this tier |
| Full-time, ~6 hrs/day | Pro from $100/mo | Max 5x $100/mo, likely Max 20x $200/mo | Codex on sticker price; Claude if session depth matters more |
| Overnight / batch heavy user | API key, pay-as-you-go, no cloud features | API + Batch API at 50% off — Sonnet 5 batch is $1 / $5 per 1M | Claude Code, because of batch discounting |
| 5-person team | 5 × $25/mo = $125/mo monthly, or $100/mo annual; Codex-only seats have no seat fee and no rate limits, pure pay-as-you-go | 5 × $20–25 Standard = $100–125/mo, or 5 × $100–125 Premium = $500–625/mo | Codex — the Codex-only seat structure has no per-seat floor |
The crossover point
The rule that falls out of the published numbers:
Subscriptions win until your usage exceeds roughly 5–10× the subscription price in metered tokens. Past that, you are paying for a cap you keep hitting, and you should be on API metering — ideally with batching.
Concretely: if Anthropic says a full-time Claude Code developer costs $150–250/month, and Max 20x is $200/month, then Max 20x is priced almost exactly at the average full-time developer’s metered cost. It is not a discount; it is a predictability product. You buy it to stop thinking about the meter, not to save money.
Three cost traps nobody mentions
- Claude 4.7+ tokenizes about 30% more tokens for the same text (Claude API pricing). Any per-million-token comparison that puts Opus 5 at $5 next to GPT-5.6 Sol at $5 and calls it a tie is wrong by roughly a third on the input side.
- Claude Code’s prompt cache lives 1 hour on a subscription but drops to 5 minutes once you start drawing on usage credits (Claude Code costs). Your effective cost per task goes up right at the moment you go over your plan — a compounding overage.
- Codex credits expire 12 months after purchase and do not roll over (credits terms). Bulk-buying credits you won’t burn is a real loss.
And one more that’s easy to trip over: Claude Code Agent Teams consume about 7× the tokens of a standard session in plan mode, which is why it ships disabled behind CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 (Claude Code costs).
Pricing, in full
Codex tiers
Codex pricing as of July 2026 runs from $8/mo (Go) to $100/mo and up (Pro), with Business seats at $25/user/mo monthly or $20/user/mo annual, plus a Codex-only Business seat that carries no seat fee and bills per token.
| Tier | Price | What you get |
|---|---|---|
| Free | $0 | Quick task exploration; included credits not disclosed |
| Go | $8/mo | Lightweight coding tasks |
| Plus | $20/mo | Web, CLI, IDE extension, iOS; cloud integrations; GPT-5.5, 5.4, 5.3-Codex, 5.4-mini |
| Pro | From $100/mo | 5x or 20x Plus rate limits; includes GPT-5.3-Codex-Spark |
| Business seat | $25/user/mo monthly · $20 annual | Codex baseline access |
| Business Codex-only seat | No seat fee, pay-as-you-go per token; OpenAI’s wording: “no rate limits” | |
| Enterprise / Edu | Contact sales | Priority processing, SCIM/EKM/RBAC, audit logs, data residency |
Source: Codex pricing · team pricing
Correction to a widely repeated error: several ranking comparisons state Codex Pro is “$200/month.” OpenAI’s own page says only “From $100/month” and does not publish a split between the 5x and 20x tiers. Treat any $200 figure you see as unsourced.
What the $100 tier actually gets you right now
One line on OpenAI’s Codex pricing page deserves separate treatment, because it is the difference between the $100 tier being a good deal and a mediocre one. The page offers double the normal usage on the $100 per month tier, with an end date of 31 May 2026. Checked on 30 July 2026, that line is still displayed, and that date is two months in the past.
We could not find any official OpenAI page saying whether the offer lapsed on schedule, was quietly extended, or was folded into the base allowance. The help centre article on Codex usage limits does not mention it. So the status of the doubling is, in the only honest phrasing available: Not published as of 30 July 2026. Two things follow. Budget against the base ranges in the table above and treat any doubling you observe as a bonus rather than an entitlement. And read a live pricing page carrying an expired date as what it is: evidence that these pages are maintained less carefully than their precision implies, which is a reason to check the figure that matters to you on the day you buy rather than trusting a comparison table, including this one.
Codex credits rate card (credits per 1M tokens)
Codex bills in credits rather than dollars: GPT-5.5 costs 125 credits per 1M input tokens and 750 per 1M output, and GPT-5.4-mini is the cheapest at 18.75 input and 113 output. Cached input is priced at exactly one tenth of input on every model listed. (Correction, 5 September 2026: this table is superseded — GPT-6 Astra has since been added and GPT-5.6 Sol’s rate was cut. The current card, and what changed, is in the 5 September update at the end of this article. The one-tenth rule below still holds for every text model.)
| Model | Input | Cached input | Output |
|---|---|---|---|
| GPT-5.5 | 125 | 12.50 | 750 |
| GPT-5.4 | 62.50 | 6.25 | 375 |
| GPT-5.4-mini | 18.75 | 1.875 | 113 |
| GPT-5.3-Codex | 43.75 | 4.375 | 350 |
| GPT-5.2 | 43.75 | 4.375 | 350 |
Source: Codex rate card
Converting credits to dollars is harder than it should be. OpenAI does not publish a general credit price. The only official anchor is a line in the student terms of service — “2,500 credits, which is equivalent to $100” (source) — implying 1 credit = $0.04. Applying that rate, GPT-5.5 works out to $5.00 input / $30.00 output per million tokens, which happens to match GPT-5.6 Sol’s published API price exactly. That’s a strong signal, but OpenAI has never stated the two are equivalent, so treat it as an observation rather than a quote.
Claude tiers
Claude Code access starts at the $20/mo Pro tier – the Free tier has none – and rises through Max 5x at $100/mo and Max 20x at $200/mo. Team Standard is $20/seat annual or $25/seat monthly.
| Tier | Price | Notes |
|---|---|---|
| Free | $0 | No Claude Code access |
| Pro | $20/mo · $17/mo annual ($200 upfront) | “At least 5× Free usage per session” |
| Max 5x | $100/mo | 5× Pro per-session usage |
| Max 20x | $200/mo | 20× Pro per-session usage |
| Team Standard | $20/seat annual · $25 monthly | Seat allowance shared with chat |
| Team Premium | $100/seat annual · $125 monthly | Larger allowance |
| Enterprise | Seat price + usage at API rates; annual only | Contact sales |
Source: Claude pricing · Max plan
Claude API prices (per 1M tokens)
Claude API list prices in July 2026 run from $1 per 1M input tokens (Haiku 4.5) to $10 (Fable 5), with Opus 5 at $5 input and $25 output. The Sonnet 5 rate of $2 in and $10 out was announced at launch as introductory pricing through Aug 31, 2026; Anthropic now states it is the standard price and that the scheduled increase to $3 and $15 will not occur.
| Model | Input | Output | Cache read | Context |
|---|---|---|---|---|
| Fable 5 | $10 | $50 | $1 | 1M |
| Opus 5 | $5 | $25 | $0.50 | 1M |
| Sonnet 5 (promo, through Aug 31 2026) | $2 | $10 | $0.20 | 1M |
| Sonnet 5 (from Sept 1 2026) | $3 | $15 | $0.30 | 1M |
| Haiku 4.5 | $1 | $5 | $0.10 | 200k |
Source: Claude API pricing
Batch API is 50% off across the board: Opus 5 at $2.50/$12.50, Sonnet 5 at $1/$5 during the promo. If your workload can tolerate latency, this is the largest single cost lever on either platform — and Codex has no published equivalent.
✅ Resolved, 31 August 2026: Sonnet 5’s $2/$10 per million token rate was announced as introductory pricing through August 31, 2026, but Anthropic’s pricing documentation now states it is the standard price and that the scheduled increase to $3/$15 on 1 September 2026 will not occur. No September revision is needed — keep budgeting at $2/$10.
Coding performance — and why the benchmark tables you’ve seen are misleading
Here is where this comparison diverges sharply from everything else ranking for this query.
What OpenAI publishes
OpenAI publishes agentic coding scores for five Codex models. GPT-5.6 Sol leads at 64.6% on SWE-Bench Pro, 88.8% on Terminal-Bench 2.1 (89.9% in ultra mode), 72.7% on DeepSWE v1.1, and 80 on the AA Coding Agent Index.
| Model | SWE-Bench Pro | Terminal-Bench 2.1 | DeepSWE v1.1 | AA Coding Agent Index |
|---|---|---|---|---|
| GPT-5.6 Sol | 64.6% | 88.8% (ultra: 89.9%) | 72.7% | 80 |
| GPT-5.6 Terra | 63.4% | 87.4% | 69.6% | 77.4 |
| GPT-5.6 Luna | 62.7% | 84.7% | 67.2% | 74.6 |
| GPT-5.5 | 58.6% | 82.7% (on TB 2.0) | — | — |
| GPT-5.3-Codex | 56.8% | 77.3% (on TB 2.0) | — | — |
Sources: GPT-5.6 · GPT-5.5 · GPT-5.3-Codex
What Anthropic publishes: nothing you can cite
Anthropic’s launch pages for Claude Opus 5, Sonnet 5, Fable 5, and Mythos 5 present their benchmark tables as images. The body text is entirely relative — phrases like “more than doubles Opus 4.8” and “3× the next-best model.” The Opus 5 announcement does not contain the strings “SWE-bench” or “Terminal-Bench” anywhere in its text.
This means there is currently no citable official agentic coding score for any frontier Claude model. Every comparison article you’ll find that lists one — including the number-one ranking result, which puts “Opus 4.8 at 88.6% SWE-bench Verified” in its meta description — is sourcing it from a third-party reproduction or an older page, not from Anthropic.
We are not going to invent a number to fill the cell. The honest state of the world is: OpenAI’s coding claims are auditable and Anthropic’s are not. Whether that changes your decision is up to you, but you should know it.
Five reasons cross-vendor benchmark tables are structurally invalid
Even setting Anthropic aside, comparing published scores across vendors doesn’t work, and here’s the specific evidence:
- Terminal-Bench 2.0 and 2.1 are not interchangeable, and vendors mix them. OpenAI’s own pages list GPT-5.5 at 82.7% on TB 2.0 and 85.6% on TB 2.1. Kimi K2.6, Qwen3.7-Max and Qwen3-Coder-Next report 2.0; GLM-5.2, MiniMax-M3 and GPT-5.6 report 2.1.
- Swapping the harness reverses rankings. GLM-5.2 self-reports 81.0 under Terminus-2 and 82.7 under Claude Code — while measuring Opus 4.8 at 85.0 under Terminus-2 and 78.9 under Claude Code (Z.ai). Anthropic lists GPT-5.5’s TB 2.1 at 83.4% via Codex CLI; OpenAI lists 85.6%.
- Scaffold spread is enormous. Qwen3-Coder-Next scores 70.6–71.3 on SWE-bench Verified across three scaffolds, but 25.8–36.2 on Terminal-Bench across four (paper). A claimed “80% SWE-bench” with no named scaffold is not a usable number.
- Sampling and effort settings differ. Kimi K2.6 reports a 10-run mean; MiniMax-M3 a 4-run mean; GLM-5.2 a 5-run mean; all OpenAI Codex figures use xhigh reasoning effort, with GPT-5.6 adding a separate ultra tier. None of these are pass@1-comparable.
- Competitor numbers inside a vendor’s table are third-party reproductions. And OpenAI’s own footnote flags evidence of memorization contamination on SWE-Bench Pro (Public).
The practical takeaway: benchmark deltas of two or three points between these two tools are noise. Decide on cost structure, working style, and failure modes instead — the next three sections.
Context, limits, and what happens when you hit the wall
Codex leads on raw context with 1,050,000 tokens against Claude Code 1,000,000, but the sharper practical difference is disclosure: Codex publishes message ranges per tier per model, Claude has never published absolute limits, and because Claude models share a single pool, switching with /model does not restore access.
| Codex | Claude Code | |
|---|---|---|
| Frontier context | 1,050,000 (GPT-5.5 / 5.4 / 5.6) | 1,000,000 (Opus 5 / Sonnet 5 / Fable 5) |
| Mid-tier context | 400,000 (5.4-mini, 5.3-Codex, 5.2) | 200,000 (Haiku 4.5) |
| Max output | 128,000 | 128,000 (300k via Batch API beta header) |
| Window structure | 5-hour rolling | 5-hour rolling + weekly cap on an account-assigned day |
| Published limits | Yes — message ranges per tier per model | No absolute numbers ever published |
| Model switching | Per-model allowances | All models share one pool — /model does not restore access |
Codex publishes actual per-window ranges (source):
Concretely, on Plus a 5-hour window allows 15-80 GPT-5.5 messages; on Pro 5x that becomes 80-400, and on Pro 20x 300-1,600. Claude Code publishes no equivalent figures at any tier.
| Tier | GPT-5.5 | GPT-5.4 | GPT-5.4-mini | GPT-5.3-Codex (local) |
|---|---|---|---|---|
| Plus | 15–80 | 20–100 | 60–350 | 30–150 |
| Pro 5x | 80–400 | 100–500 | 300–1,750 | 150–750 |
| Pro 20x | 300–1,600 | 400–2,000 | 1,200–7,000 | 600–3,000 |
Anthropic publishes no equivalent table. Across claude.com/pricing, the Pro plan article, the Max plan article, and the Claude Code usage article, there is not a single token count, message count, or hour figure for the weekly limit. Every “X hours of Opus per week” figure circulating online is secondhand. The one hard rule Anthropic does state is that all models draw on the same pool — a detail that surprises people who assume switching to Sonnet buys them more runway. It doesn’t. Use /usage and /status to see where you stand.
When you hit the wall: on both platforms you can buy your way past it. Claude sells extra usage at standard API rates (capped at $2,000/day in added funds); Codex sells additional credits on Plus and Pro without requiring an upgrade. The difference is the hidden cost — as noted above, Claude’s cache lifetime drops from 1 hour to 5 minutes the moment you start drawing on credits, so your unit economics quietly worsen exactly when you’re over budget.
Codex and Claude Code are only two of the bills a working developer actually pays. For the wider picture — Copilot’s AI Credits, Cursor’s allowances, the $18/mo GLM plan that runs inside Claude Code, and where each subscription stops being cheaper than the API — see our full analysis of AI coding assistant pricing.
Both sides share a pool, but they share different things
Neither product gives coding its own private allowance, and the two vendors pool usage along different axes. On Claude Code the pool is shared across models: Anthropic states that all models draw on the same pool, so reaching for /model after you hit a wall does not buy back any room. On Codex the pool is shared across products. OpenAI’s help centre article on using Codex with a ChatGPT plan says that usage from Codex, ChatGPT Work, ChatGPT for Excel and Workspace Agents “draws from the same agentic usage and credit pool” (OpenAI Help Center, checked 30 July 2026).
That distinction changes how you should read the numbers on each vendor’s pricing page. The per-window message ranges Codex publishes assume the whole agentic pool is yours to spend on code; if you also run spreadsheet agents or ChatGPT Work tasks during the day, the coding figure you actually experience is lower than the published range, and nothing in the interface attributes the loss to those other products. Claude Code has the opposite shape: your allowance is only ever consumed by Claude Code, but you cannot escape a limit by dropping to a cheaper model, because the cheaper model is drawing on the same pool you just exhausted.
How each one fails
Choosing an AI coding agent on its best day is a mistake; you live with it on its worst day. The failure modes are different in kind, not just degree.
Claude Code’s characteristic failure is over-confidence on partial context. In long sessions, context compression discards material and the agent proceeds as though it still has it. The most instructive documented pattern: an agent fixed a bug in one UI panel and reported the task complete, having never noticed the identical bug in the adjacent panel it had read forty minutes earlier. The related failure is over-refactoring — asked to fix one function, it improves six, and now your diff is unreviewable. Mitigation: shorter sessions, explicit scope constraints in CLAUDE.md, and /fork for background exploration so your main session stays clean.
Codex’s characteristic failure is silent drift on long-horizon autonomy. It is built to run unattended for extended stretches, which means it will confidently continue down a wrong path for a long time before you see the result. It also more readily ignores existing project conventions in favor of generic idiomatic code. Mitigation: a thorough AGENTS.md, and reviewing at milestones rather than at the end.
Both share three failure modes worth naming: hallucinated APIs on less-common libraries, false test-pass claims (an agent reporting green when it ran a subset, or ran nothing), and sandbox-boundary surprises. Codex’s sandbox is kernel/OS-level; Claude Code’s is application-layer and programmable — the latter is more flexible and, correspondingly, easier to configure into something permissive. Never accept “tests pass” without seeing the output.
Whose servers keep your code, and for how long
Every comparison of these two tools argues about speed, output quality and price. Almost none of them answer the question that actually stops a purchase inside a company: does the vendor train on the code you send, and how long is it kept. Both vendors publish answers. The answers are not symmetric, and neither is the amount each vendor is willing to put in writing.
| Question | Codex (OpenAI) | Claude Code (Anthropic) |
|---|---|---|
| Used for training on individual plans, by default | Yes. For services for individuals such as ChatGPT and Codex, OpenAI says “we may use your content to train our models”. | Only when the setting is on. Anthropic trains on Free, Pro and Max data “when this setting is on”, including Claude Code used from those accounts. |
| Business, Enterprise and API | Not by default: “we do not train on any inputs or outputs from our products for business users”. | Not by default: Anthropic “does not train generative models using code or prompts sent to Claude Code” under commercial terms. |
| How you turn it off | Through the privacy portal, by selecting “do not train on my content”. | In the account’s data privacy controls, changeable at any time. |
| Retention on individual plans | No Codex-specific figure published. Deleted conversations are removed “within 30 days”. | Published, and split by your choice: five years if you allow training, 30 days if you do not. |
| Retention on business plans and API | “up to 30 days” for API inputs and outputs, to run the service and identify abuse. | 30 days standard for Team, Enterprise and API. |
| Zero-retention option | ZDR on request “for eligible endpoints if you have a qualifying use-case”. | Zero data retention for Claude Code on Enterprise, for qualified accounts only, and explicitly not part of the standard Enterprise plan. |
| What is written to your own disk | Not published. | Session transcripts, in plaintext, under ~/.claude/projects/ for 30 days by default, adjustable with cleanupPeriodDays. |
Three things in that table are worth saying out loud.
The individual-plan default is the opposite of what most developers assume. The instinct is that a paid plan buys privacy. On a personal ChatGPT plan it does not: OpenAI’s own data controls FAQ puts Codex in the same sentence as ChatGPT and says content may be used for training. Anthropic’s consumer default is a choice rather than an automatic yes, which sounds better until you notice what the choice is attached to. Saying yes moves you from a 30-day retention period to a five-year one. Neither posture is dishonest. They are simply different, and the difference is invisible unless you read both policy pages, which is not something a benchmark table can do for you.
Anthropic publishes more numbers here than OpenAI does. Anthropic states retention periods for Claude Code specifically, split by plan and by training preference. We could not find an official OpenAI page that states a retention period for Codex as such; the 30-day figures above come from OpenAI’s enterprise privacy page and describe conversations and API traffic generally. That is not an accusation, and it does not mean Codex keeps your code longer. It means the figure is not published, so we have written “not published” rather than borrowing a number from somewhere it does not belong.
Only one of the two documents what lands on your own laptop. Claude Code writes session transcripts to disk in plaintext and Anthropic says so, gives the default period, and names the setting that changes it. That is a point in favour of the documentation and a point against running either tool on an unencrypted work machine, since a transcript of an agent editing your repository is a fairly complete description of that repository.
If your decision is being made for a team rather than for yourself, this section is likely to matter more than any benchmark on this page. Both vendors keep business and API traffic out of training by default, so the real question is which plan you are actually on. A team paying for individual seats and calling it a business deployment gets the individual-plan policy, on both sides.
Using both together — the actual setup
Every comparison says “just use both.” None of them tell you how. Here is the concrete arrangement, which costs $40/month at the mainstream tiers ($20 Plus + $20 Pro).
One shared instruction file. Codex reads AGENTS.md; Claude Code reads CLAUDE.md. Write the substance once in AGENTS.md and make CLAUDE.md a short file that points to it plus Claude-specific directives. Keeping two full copies guarantees they drift.
Map your MCP config across both. Claude Code uses .mcp.json; Codex uses ~/.codex/config.toml. The server definitions translate mechanically; do it once and keep both in version control so a teammate isn’t reconstructing it.
Isolate with git worktrees. Running both agents in the same working tree produces conflicts that look like bugs. One worktree per agent, merge deliberately.
Split by strength, not by mood. The division that holds up: Claude Code for exploratory and reasoning-heavy work (understand this system, design this migration, why is this failing), Codex for well-specified long-horizon execution (implement this spec, run this migration across 40 files). Then have each review the other’s output — cross-model review catches a meaningful class of error that self-review does not, because the two models fail differently.
Use a handoff file. A simple append-only changes.log in the repo, written by whichever agent just finished, is enough for the next one to pick up context without re-reading the entire diff.
Who should choose what
Choose Codex if: you want the lowest floor (the $8 Go tier has no Claude equivalent), you want published rate limits you can plan around, you run long unattended tasks, your team wants seats without a per-seat floor, or you need auditable benchmark claims.
Choose Claude Code if: your work is exploratory and reasoning-heavy, you want the deepest extensibility surface (MCP, hooks, skills, plugins, subagents), you run batch workloads where the 50% Batch API discount dominates, or you’re deploying through Bedrock, Google Cloud Agent Platform, or Microsoft Foundry.
Choose both if you’re a full-time professional developer. At $40/month combined, against an official per-developer cost of $100–250/month for either one alone, the second subscription is a rounding error — and cross-model review is the single highest-value thing you can do with it.
Choose neither yet if you’re evaluating on benchmark scores. Given the methodology problems above, a one-week trial of both on the same real task in your own repo will tell you more than every published number combined. Our 2026 AI coding model roundup covers the rest of the field, including the open-weight challengers.
If neither tool fits the way you work, or the price is the sticking point, we compared twelve Claude Code alternatives in a separate piece, including the break-even math for when a flat monthly plan beats paying per token.
FAQ
Is Codex or Claude Code better for coding in 2026? Neither, categorically. Codex is cheaper at every tier and publishes its limits; Claude Code is stronger on exploratory, reasoning-heavy work and has deeper extensibility. Published benchmark gaps between them are not methodologically comparable, so decide on cost structure and working style instead.
What’s the real monthly cost of each? Well above the $20 sticker price. Anthropic publishes $150–250 per developer per month for Claude Code; OpenAI estimates ~$100–200 per developer per month for Codex. The $20 tiers are entry points, not the working price for a full-time developer.
Which has better usage limits? Codex publishes actual message ranges per tier (Plus: 15–80 GPT-5.5 messages per 5-hour window; Pro 20x: 300–1,600). Anthropic has never published absolute limits for any Claude tier. Note that Claude’s 5-hour Claude Code limits were doubled in 2026 and all models share one pool.
Can I use Codex and Claude Code together?
Yes, and for a full-time developer it’s the recommended setup at $40/month combined. Share one AGENTS.md, mirror your MCP config across .mcp.json and ~/.codex/config.toml, isolate with git worktrees, and have each review the other’s output.
Which has the larger context window? Codex, marginally: 1,050,000 tokens on GPT-5.5, 5.4 and 5.6, versus 1,000,000 on Claude Opus 5, Sonnet 5 and Fable 5. The 5% difference is immaterial. What matters more is that Claude 4.7+ tokenizes roughly 30% more tokens for the same text, so the effective usable context is closer than the headline numbers suggest.
Is GPT-5.6 available in Codex? Not confirmed. GPT-5.6 (Sol, Terra, Luna) shipped July 9, 2026 and OpenAI’s help center confirms availability in ChatGPT by plan. As of this writing, neither the Codex pricing page nor the Codex rate card lists any GPT-5.6 entry. Check your own account before buying a plan for it.
Why doesn’t this article list Claude’s SWE-bench score? Because Anthropic doesn’t publish one as citable text. The benchmark tables on the Opus 5, Sonnet 5, Fable 5 and Mythos 5 launch pages are images, and the body copy uses only relative comparisons. Any specific Claude score you see quoted elsewhere comes from a third-party reproduction, not from Anthropic.
How much does Codex Pro cost — $100 or $200? OpenAI publishes only “From $100/month” and does not break out prices for the 5x and 20x tiers. The $200 figure that appears in several comparisons is not on any official OpenAI page.
Last verified: July 2026, against official vendor documentation. Pricing and model availability in this category change monthly; this page is reviewed on a rolling 30-day cycle. Sonnet 5’s introductory API rate became its standard price on 1 September 2026; the scheduled increase to $3/$15 will not occur.
Related: Claude Max vs ChatGPT Pro: what 5x and 20x actually mean — what the tier multipliers do and do not cover, quoted from each vendor.
For the metering side rather than the cost side, see Codex usage limits by tier and whether Claude Code is free.
Update, 30 August 2026: two pricing changes that affect the tables above
Claude Sonnet 5 did not go up in price on 1 September 2026. Anthropic’s pricing documentation now states that the $2/$10 per million input/output token rate, announced at launch as introductory pricing through 31 August 2026, is the standard price, and that the previously scheduled increase to $3/$15 will not occur. Any monthly estimate on this page that assumed the rise should be left as it stands.
There is now a third option worth pricing against these two. Z.ai’s GLM Coding Plan starts at $18 a month and runs inside Claude Code itself through an Anthropic-compatible endpoint, which makes it a direct cost alternative to both tools compared here rather than a separate product. We priced the same week of agentic coding on Anthropic’s API, Anthropic’s flat plans and Z.ai’s credit system in GLM Coding Plan vs Claude Code — including the one line item where Anthropic comes out cheaper.
Update, 1 September 2026: a note on the third option
This comparison holds Codex and Claude Code against each other, but a lot of teams reading it are actually choosing between three things, and the third one changed its economics today. GitHub’s promotional included usage for existing Copilot Business and Copilot Enterprise customers ran from 1 June to 1 September 2026 and has now lapsed. Per GitHub’s billing documentation the standard allowances are 1,900 AI credits per seat on Business and 3,900 on Enterprise, down from the promotional 3,000 and 7,000, with credits fixed at $0.01 each.
The consequence that is easy to miss, and that we work through in our Claude Code versus GitHub Copilot comparison, is that at the standard allowance a Copilot seat now returns exactly its own price back as metered usage — $19 of credits on a $19 seat, $39 on a $39 seat (our arithmetic on GitHub’s official figures). That does not make Copilot cheaper or dearer than either option compared on this page; it just means the seat fee stops carrying a usage subsidy, which is the number a rollout budget actually depends on.
Separately, and unrelated to GitHub: the Sonnet 5 price increase this page previously flagged for 1 September did not happen. Anthropic’s $2/$10 per million input/output tokens is now the standard rate, as noted above.
Update, 3 September 2026: the long-context line nobody compares
We re-read both vendors’ official pricing pages on 3 September 2026. Neither headline price moved. What we did find is a structural difference that almost no comparison of Codex and Claude Code mentions, because it does not appear in the row everyone quotes: OpenAI publishes two price tiers per model for its GPT-5.6 family — a short-context price and a long-context price — while Anthropic bills its entire context window at one rate. On agentic coding work, where the context is the repository and it only grows, that is the difference that decides the invoice.
What the two pricing pages actually publish
Anthropic’s pricing documentation states, verbatim, that Claude 4.6 and later models “include the full 1M token context window at standard pricing”, and adds the illustration that a 900k-token request is billed at the same per-token rate as a 9k-token request. Prompt caching and batch discounts are stated to apply at standard rates across the full window. There is no second column.
OpenAI’s API pricing table has eight columns per model for the GPT-5.6 family: short-context input, cached input, cache writes and output, then the same four again for long context. These are the published standard-tier list prices, read 3 September 2026:
| Model (per 1M tokens) | Input | Cached input | Output |
|---|---|---|---|
| gpt-5.6-terra, short context | $2.00 | $0.20 | $12.00 |
| gpt-5.6-terra, long context | $4.00 | $0.40 | $18.00 |
| gpt-5.6-sol, short context | $4.00 | $0.40 | $20.00 |
| gpt-5.6-sol, long context | $8.00 | $0.80 | $30.00 |
| gpt-5.3-codex (the Codex model) | $1.75 | $0.175 | $14.00 |
| Claude Sonnet 5, any context length | $2.00 | $0.20 | $10.00 |
| Claude Opus 5, any context length | $5.00 | $0.50 | $25.00 |
One caveat on that table before anyone builds a spreadsheet from it. OpenAI’s pricing page annotates the GPT-5.5 and GPT-5.4 rows with “(<272K context length)”, but it does not state on that page where the short/long boundary sits for the 5.6 family. We are not going to guess a threshold. Treat the long-context column as the price you pay once a request is large enough to cross a line OpenAI has not published in this table, and check your own billing dashboard for where that happened.
The ranking flips at the tier boundary
This is the part that gets lost. Our arithmetic on the official numbers above: at short context, gpt-5.6-terra and Claude Sonnet 5 charge exactly the same $2.00 for input, and terra’s output is 1.2x Sonnet 5’s. Cross into the long-context tier and terra becomes 2.0x Sonnet 5 on input and 1.8x on output — without either vendor changing a headline price. The cached-read line moves the same way: $0.40 against $0.20, also 2.0x.
The flagship comparison actually inverts. Our arithmetic: gpt-5.6-sol’s short-context output at $20.00 is cheaper than Claude Opus 5’s $25.00. Its long-context output at $30.00 is more expensive. Any table that prints one number per model has silently picked a side of that boundary for you, and every “model X is cheaper than model Y” verdict built on it is conditional on a context length the table never mentions.
What it means for Codex against Claude Code specifically
Here the news is better for Codex than the paragraphs above imply, and it is worth being precise about it. gpt-5.3-codex — the model the Codex CLI is built around — has no long-context row on OpenAI’s pricing page at all. It is listed once, under specialised models, at $1.75 input, $0.175 cached input and $14.00 output, with a Fast mode variant at $3.50 and $28.00. So the two-tier structure is a property of the general-purpose 5.6 family, not of the Codex model itself.
That matters for how you read the rest of this page. If you drive Codex through the CLI on its default model, the tier boundary is not your problem, and gpt-5.3-codex’s $0.175 cached-input line is the cheapest cached read of any model in the table above. If you route agent work through gpt-5.6-terra or sol — which is what most people mean when they say they are “on GPT-5.6” — then it is your problem, and it gets worse exactly as your repository context gets larger. Claude Code’s position is unchanged either way: one rate, whatever you load.
We work through what actually fills that window, and how fast, on our Claude Code context window page. The full cross-vendor rate card, including the seat-based plans, is on our AI coding assistant pricing page, and the wider model-by-model view is in AI coding models compared.
Three places the two vendors have quietly converged
While we were checking the tier question, three lines turned out to be identical on both pricing pages. None of them is announced anywhere, and all three change how you should read a cost comparison.
- Cache multipliers now match. Anthropic publishes them explicitly: 1.25x base input for a 5-minute cache write, 2x for a 1-hour write, 0.1x for a cache read. OpenAI publishes prices rather than multipliers, but our arithmetic on the gpt-5.6 rows gives the same two numbers — $5.00 cache write against $4.00 input on sol is 1.25x, and $0.40 cached input against $4.00 is 0.1x. Caching therefore no longer differentiates the two vendors at all; only the base price it multiplies does.
- Data residency costs 10% on both sides. OpenAI: “Regional processing (data residency) endpoints are charged a 10% uplift for models released on or after March 5, 2026.” Anthropic: pinning
inference_geotousapplies a 1.1x multiplier on Claude 4.6 and later, across input, output, cache writes and cache reads. If your procurement rules require in-region inference, both bills go up by the same tenth. - Both now sell a “Fast mode”, and they mean different things by it. OpenAI states that priority processing was renamed Fast mode on 30 July 2026; gpt-5.3-codex in Fast mode is $3.50 and $28.00, exactly double the standard rate (our arithmetic). Anthropic’s Fast mode is a research preview limited to Opus 5 and Opus 4.8 at $10.00 and $50.00, also double those models’ standard $5.00 and $25.00 (our arithmetic). Same name, same 2x, different scope — OpenAI offers it on the coding model, Anthropic does not.
Why you still cannot divide one price by the other
Every ratio in this update is a ratio of list prices for one million tokens, and a token is not the same object on both sides. Anthropic’s own documentation states that Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text”, with the exact increase depending on content and workload shape. Claude Sonnet 5 is in that group. So a per-million-token price that looks equal is not a per-unit-of-work price that is equal, and the direction of that error runs against Anthropic.
We have not found a published cross-vendor tokenisation benchmark we would be willing to stand behind, so we are not going to invent a conversion factor here either. The honest summary is narrower than a ratio and more useful than one: on OpenAI the price of a token depends on how many other tokens are in the request; on Anthropic it does not. Everything else in a cost comparison is arithmetic you can redo when your own usage report arrives.
Two dates worth putting in a calendar
OpenAI’s pricing page carries one forward-looking line: “GPT-5.6 Sol’s promotional pricing is available at least through November 21, 2026.” The wording is “at least”, so this is a floor and not an expiry — but the $4.00 and $20.00 short-context figures in the table above are promotional, and the page does not say what they revert to. Anthropic’s side has no pending change: the Sonnet 5 $2.00 and $10.00 rate is now the standard price and the previously scheduled increase to $3/$15 will not occur.
Sources, both read 3 September 2026: OpenAI API pricing and Anthropic pricing documentation. Figures are official list prices; every ratio and multiplier derived from them is marked as our arithmetic.
Update, 5 September 2026: the credit rate card moved, and the two vendors now line up at exactly 2×
Both vendors’ pricing pages were re-read on 5 September 2026. Anthropic’s had not changed. OpenAI’s had, in two ways — and the second one produces the cleanest cross-vendor result this article has been able to state so far.
The rate card table earlier in this article is out of date
The Codex credits rate card table above lists GPT-5.5, GPT-5.4, GPT-5.4-mini, GPT-5.3-Codex and GPT-5.2. Those are no longer the models at the front of OpenAI’s card. We are leaving the original table in place rather than overwriting it, because the comparison between the two readings is itself the finding. Here is the card as published on 5 September 2026:
| Credits per 1M tokens | Input | Cached input | Output |
|---|---|---|---|
| GPT-6 Astra (new) | 250 | 25 | 1,250 |
| GPT-5.6 Sol (was 125 / 12.5 / 750) | 100 | 10 | 500 |
| GPT-5.6 Terra | 50 | 5 | 300 |
| GPT-5.6 Luna | 5 | 0.5 | 30 |
| GPT-5.5 | 125 | 12.50 | 750 |
| GPT-5.4 | 62.50 | 6.250 | 375 |
| GPT-5.4 mini | 18.75 | 1.875 | 113 |
So: a new top model, and a 20% cut to Sol’s input and cached-input rate with a 33.3% cut to its output rate (our arithmetic). Every other pre-existing row held exactly. We cover what that means for included message allowances in Codex usage limits; the short version is that the message ranges did not move when the prices did.
Both rate cards have the same shape, which is why one number decides everything
Put the two cards side by side and the same two ratios fall out of both.
Cached input is one tenth of input on every text model on both cards. On OpenAI’s: 250→25, 100→10, 50→5, 5→0.5, 125→12.5, 62.50→6.250, 18.75→1.875. On Anthropic’s the same relationship is stated as a rule rather than a table — cache reads are billed at “0.1x base input price.” Two vendors, two currencies, identical cache economics.
Each card has exactly one exception, and they point in opposite directions. OpenAI’s two GPT-Image-2 rows break the pattern by charging more for cached input than the rule implies: 200→50 and 125→31.25, a quarter rather than a tenth (our arithmetic). Anthropic’s exception goes the other way — cache hits on Claude Fable 5.1 and Claude Mythos 5.1 are billed at 0.025x base input, a fortieth rather than a tenth. If you are running an image-heavy Codex workload or a Fable/Mythos workload, the headline cache discount does not apply to you, in one direction or the other.
Output is a fixed multiple of input on both sides. Anthropic prices output at 5× base input across its entire published lineup — Sonnet 5 $2→$10, Opus 5 $5→$25, Haiku 4.5 $1→$5, Fable 5.1 $10→$50. OpenAI is 5× on its two frontier models (Astra 250→1,250, Sol 100→500) and 6× on everything below them (our arithmetic).
The consequence is worth stating plainly, because it is the reason most Codex-versus-Claude-Code cost comparisons are shaped wrong. When two rate cards have the same internal ratios, the entire “which is cheaper per token” question collapses to a single unknown scalar: the dollar value of one credit. There is no workload mix that flips the answer, because the mix cancels. You are not comparing pricing structures. You are comparing one number that OpenAI does not publish.
Applying the one anchor that exists: an exact 2.00× on both frontier pairs
Earlier in this article we noted the only official credit-to-dollar anchor we have been able to find: a line in OpenAI’s student terms reading “2,500 credits, which is equivalent to $100” — implying 1 credit = $0.04. OpenAI has never stated that this rate applies generally, and it is not a published price list. Treat everything in this subsection as our arithmetic on an unofficial anchor, not as a vendor quote.
With that caveat carried in full, apply $0.04 to the card as it reads today:
| Per 1M tokens | Input | Cached input | Output |
|---|---|---|---|
| GPT-6 Astra at $0.04/credit | $10.00 | $1.00 | $50.00 |
| Claude Opus 5 (official) | $5.00 | $0.50 | $25.00 |
| Ratio | 2.00× | 2.00× | 2.00× |
| GPT-5.6 Sol at $0.04/credit | $4.00 | $0.40 | $20.00 |
| Claude Sonnet 5 (official) | $2.00 | $0.20 | $10.00 |
| Ratio | 2.00× | 2.00× | 2.00× |
| GPT-5.6 Terra at $0.04/credit | $2.00 | $0.20 | $12.00 |
| Claude Sonnet 5 (official) | $2.00 | $0.20 | $10.00 |
| Ratio | 1.00× | 1.00× | 1.20× |
Three things fall out of that table, and none of them appear in any comparison we have read.
- Both frontier pairs land on exactly 2.00×, on all three lines. Astra against Opus 5 and Sol against Sonnet 5 give the same constant. That is what the shape identity above guarantees once the two cards share the 1 : 0.1 : 5 ratio — but the fact that the constant is a round 2.00 rather than, say, 1.87 is not guaranteed by anything, and it is new.
- The September cut is what created it. On the 21 August card, Sol at $0.04/credit worked out to $5.00 input against Sonnet 5’s $2.00 — a ratio of 2.50×. The cut moved it to exactly 2.00× (our arithmetic).
- Terra is the parity model. At this anchor Terra prices identically to Claude Sonnet 5 on input and cached input, and 20% above it on output. Anyone choosing on price alone between Sonnet 5 and a mid-tier Codex model is choosing between two nearly identical bills, not between a cheap option and an expensive one.
Why 2.00× per token is not 2.00× on your invoice
Every number above is per token, and a token is not the same size at the two vendors. Anthropic’s pricing page carries a note that most comparisons skip entirely: Claude 4.7 and later models use a newer tokenizer that “produces approximately 30% more tokens for the same text.” Claude Sonnet 5 and Claude Opus 5 are both on that tokenizer. Claude Sonnet 4.6 and earlier are not.
So for one fixed body of source code, Claude bills roughly 1.3 times as many tokens as the per-token rate suggests. Carrying that through: a 2.00× per-token gap narrows to roughly 1.54× per unit of actual text (2.00 ÷ 1.3, our arithmetic). Terra, which looked like parity with Sonnet 5 on input, comes out roughly 23% cheaper than Sonnet 5 for the same file on that adjustment.
Anthropic says the exact increase “depends on the content and workload shape,” so 30% is a vendor-published approximation, not a constant. We are not going to pretend it resolves to a single number. The point is directional and it is large: any cross-vendor per-token price comparison that does not mention the tokenizer is wrong by something in the region of a third, and it is wrong in Anthropic’s favour when you correct it.
Stack the two effects and the honest summary for a frontier-tier agent workload is: OpenAI’s newest models cost on the order of half again as much as Anthropic’s per unit of code processed, if a credit is worth $0.04. That conditional is doing an enormous amount of work, and it is the reason we keep declining to publish a single headline “X is N times cheaper” figure for this comparison.
A fourth quiet convergence
The Three places the two vendors have quietly converged section above now needs a fourth entry. Both vendors have shipped a premium-speed tier, and both price it as a flat multiplier on the standard rate: OpenAI applies “a 2.5x multiplier to Astra’s Standard rate” for fast mode, and Anthropic’s fast mode prices Opus 5 at $10 / $50 per million against a standard $5 / $25 — exactly 2× (our arithmetic). Both are described by their vendors as research previews. Neither existed in this form when this article was first written.
For the pricing picture across all the tools we track, see AI coding assistant pricing. For the tier-by-tier limit numbers behind the Codex side of this article, see Codex usage limits and Claude Max vs Codex usage limits.
Sources for this update: OpenAI’s official Codex pricing documentation and Anthropic’s official Claude platform pricing documentation, both read 5 September 2026. Vendor list prices are quoted as published; every ratio, percentage and dollar conversion is our arithmetic and is labelled as such.
Update, 17 September 2026: GPT-5.5 leaves Codex on 14 October — but does not leave the API, and still has not left OpenAI’s own rate card
GPT-5.5 appears in several of the comparison tables above. OpenAI’s pricing documentation now carries a notice at the top stating that the model retires from ChatGPT, ChatGPT Work and Codex on 14 October 2026, and that the API is not affected. That is 27 days from the date of this update (our arithmetic). If you are reading this page to decide what to standardise your team on, that date matters more than any benchmark on it.
“Retired” is not one event, and for a coding agent it is two different ones
The distinction the notice draws is the one that actually determines whether this affects you, and it is invisible in every model comparison table including ours, because a table has one row per model and no column for which door you came through.
| How you reach GPT-5.5 | Status after 14 October 2026 | What you should be doing now |
|---|---|---|
| Codex (the coding agent this page compares) | Gone | Test your prompts and agent configs against the successor model before mid-October, not after |
| ChatGPT / ChatGPT Work | Gone | Same, for any saved workflows or custom instructions tuned to it |
| Direct API calls | Not affected, per the notice | Nothing forced — but see the caveat below about how long “not affected” tends to last |
So “is GPT-5.5 going away?” has no single correct answer, and the two answers point in opposite directions for the two populations most likely to ask. Codex users lose the model outright. API users lose nothing on that date. If your team has some people in the Codex product and some calling the API directly — which is the normal shape of a team that adopted an agent gradually — you are about to have a capability split inside one team, on a date nobody circled, because the announcement reads as reassuring if you skim it.
The vendor’s own pages disagree with each other, and this is the third model in a row to do it
Here is the part we think is actually useful, because it is a rule you can apply rather than a fact that expires. On the same documentation that carries the retirement notice, GPT-5.5 is still listed on the usage-allowance table and still listed on the credit rate card. We have now re-read that page on eight separate days and the contradiction has been present every time.
It is also not a one-off. GPT-5.4 and GPT-5.4 mini sit in exactly the same state — announced for retirement, still carried on the tables. Three models, one pattern. At three instances, this stops being an oversight and becomes a property of how these pages are maintained:
- The retirement notice updates first. The rate card updates later, or not at all.
- Therefore, when a vendor’s banner and its table disagree about whether a model exists, the banner is the newer document.
- Therefore, a model’s presence on a rate card is not evidence that it is still available on the surface you use. It is only evidence that nobody has edited that table yet.
We arrived at the same conclusion twice more this week from completely different directions, which is why we are confident it generalises rather than being one vendor’s sloppiness:
- The opposite failure, at another vendor. DeepSeek announced it was phasing out its flagship and then, in a changelog entry dated the same day, said it would keep serving it — while the original announcement stayed up. There the table was right and the announcement was wrong. We wrote that up on our AI coding assistant pricing page, which also carries our correction of a model our own table listed after the vendor had retired it.
- The same failure, in reverse, at a third vendor. Z.ai published a pricing change on a notice page that its pricing page does not link to, and it sat there for 49 days before we found it. Details on our GLM Coding Plan vs Claude Code comparison.
Three vendors, three different mechanisms, one shared root cause: none of them maintains a model’s lifecycle status in a single place. Availability lives in notices, prices live in tables, and the two are edited by different people on different schedules. The practical consequence for anyone pinning a model in production is blunt — the pricing page is not your source of truth for whether a model still exists. Read the notice or changelog directory, and re-read it on a schedule, because that is where the existence question is answered and it is not the page you have bookmarked.
What we are not saying
We are not predicting an API retirement date for GPT-5.5. The notice says the API is unaffected and gives no further date, and we are not going to manufacture one from the product-surface timeline. What we will say, because it follows from the pattern above rather than from speculation: “not affected” is a statement about today, published by the same documentation set that is currently three models behind on its own tables. Treat it as accurate and as perishable.
For what this means for your Codex usage allowance specifically, see our breakdown of Codex usage limits. As always, cross-vendor per-token prices on this page are not strictly comparable: Anthropic states that Claude 4.7 and later tokenize the same text into roughly 30% more tokens than earlier models, so identical rate cards do not mean identical bills.
Source for this update: the retirement notice, usage-allowance table and credit rate card on OpenAI’s pricing documentation at learn.chatgpt.com/docs/pricing, read 17 September 2026 and on seven earlier dates. The 27-day figure is our arithmetic from the stated 14 October 2026 date. We have not restated the notice’s exact wording beyond the retirement date and the affected surfaces.
Update, 19 September 2026: two vendors who agree on nothing else both price US data residency at exactly 10%
If your employer requires that inference run inside the United States, none of the model comparisons on this page are the comparison you need — residency is a surcharge that sits on top of whichever model you picked. It is also, as far as we can tell, uncovered: across the fourteen articles on this site before today, the words “data residency” appeared four times in total, and never with a price attached. On 19 September 2026 we read xAI’s and Anthropic’s pricing pages and found that both publish the number, and that the number is the same.
The two clauses, quoted
xAI: “Requests sent to the US regional endpoint, https://us.api.x.ai/v1, run inference in the United States; their token usage is billed at 1.1x the global token rates, a 10% premium.” It applies to input, output and cached input, and to the long-context surcharge as well. Anthropic prices its inference_geo: "us" option at the same 1.1x, and states separately that its Bedrock and Google Cloud regional endpoints “include a 10% premium over global endpoints.”
Two vendors with entirely different pricing philosophies — one with a 50% line-wide batch discount, one with almost no batch discount at all; one with a flat long-context policy, one that doubles everything past 200k — landed independently on the same 10%. We have no evidence about why and will not speculate. But as a planning number, “budget 10% on top for US residency” now has two independent vendors behind it rather than one, which is more than most surcharge assumptions get.
| Per 1M tokens | Global | US residency | Absolute premium |
|---|---|---|---|
| Sonnet 5 input | $2.00 | $2.20 | +$0.20 |
| Sonnet 5 cached input | $0.20 | $0.22 | +$0.02 |
| Sonnet 5 output | $10.00 | $11.00 | +$1.00 |
grok-4.6 input | $2.00 | $2.20 | +$0.20 |
grok-4.6 cached input | $0.50 | $0.55 | +$0.05 |
grok-4.6 output | $6.00 | $6.60 | +$0.60 |
Where the multiplier sits in the order of operations decides what residency actually costs you
xAI is explicit that the cache discount is computed first and the 1.1x is applied afterwards. That single ordering detail matters more to a coding agent’s bill than the 10% itself, because it means the premium scales with what you were going to pay, not with the list price.
Work it through on Sonnet 5 with a million input tokens. An agent re-sending a largely unchanged repository at a 95% cache-hit rate pays 950,000 tokens at $0.20 plus 50,000 at $2.00, which is $0.29; residency adds about 2.9 cents. The same million tokens with no caching at all costs $2.00, and residency adds 20 cents — roughly seven times more in absolute terms for the identical compliance guarantee (our arithmetic). The better your cache hit rate, the less US residency costs you, and nothing on either pricing page says so. Teams that have already done the work to keep their prompt prefixes stable have, without intending to, also made their compliance surcharge nearly free.
The corollary is the uncomfortable one. Workloads with poor cache locality — one-shot code review of unrelated files, batch classification over a heterogeneous corpus, anything that does not re-send a stable prefix — pay the full 10% on the full list price. Residency is cheapest for the workloads that were already cheap.
At xAI, residency and the batch discount are mutually exclusive today
This is the finding we would most want on a procurement checklist, and it only appears if you read two clauses on the same page against each other rather than one at a time.
xAI states that the US regional endpoint currently supports grok-4.6 only. xAI also names the four models that receive the 20% batch discount, and closes that list with “Models not listed above have no batch discount” — and grok-4.6 is not among the four. Put the two together: the single model you can run under US residency is the single model that receives no batch discount, and the four models that receive the discount cannot be run under US residency at all.
For a regulated team with a large asynchronous workload — nightly test generation, bulk migration, scheduled review — that is not a 10% decision. It is a choice between US residency and a 20% discount, with no configuration that gives you both. Neither clause says this; each is unremarkable on its own. The interaction is the whole finding, and it exists only because both clauses happen to be printed on the same page.
What is officially not published
Three things we looked for and did not find, stated here rather than filled in from third-party sources: neither vendor publishes how the batch discount and the regional premium stack, or in which order, in the case where both apply; xAI does not publish when or whether further models will be added to the US endpoint; and neither publishes a non-US regional option with a price attached. If residency in a specific jurisdiction other than the US is your requirement, the published pricing pages do not answer you, and we are not going to invent a number.
One last caution, which applies to every dollar figure above. Anthropic states that Claude 4.7 and later use a tokenizer that produces approximately 30% more tokens for the same text. A 10% surcharge computed on a token count that is itself 30% higher is not comparable to a 10% surcharge on another vendor’s count. The surcharge percentages are comparable; the bills they produce are not.
For the rest of what xAI published on that page — the batch structure, the 2x priority tier and a per-request fee that is not a function of tokens — see our cross-vendor pricing breakdown. The long-context surcharge that the residency premium multiplies on top of is dissected in our context-window pricing analysis. And for the baseline model-by-model picture underneath all of these surcharges, start with our overall model comparison.
Update, 23 September 2026: both sides of this page changed model lineup in the same week, and Anthropic’s new flagship now has the same cached-input price as its mid-tier model
This comparison was written around GPT-5.6 on the Codex side and Claude Opus 5 on the Anthropic side. Between 22 and 23 September 2026, both of those anchors moved. Anthropic’s API pricing page added Claude Opus 5.5. OpenAI’s Codex pricing page added GPT-6 Sol and GPT-6 Luna to both the rate card and the usage table. Neither change was announced on the page as a change; both simply appeared. Everything below is quoted from those two pages as read on 23 September 2026.
Claude Opus 5.5, as published
- Input: $4 per million tokens
- Cache write, 5-minute TTL: $5. Cache write, 1-hour TTL: $8
- Cache hit: $0.20
- Output: $20 per million tokens
- Batch: $2 / $10
- Fast mode: $8 / $40 — note that Opus 5 and Opus 4.8 remain at $10 / $50
Against Opus 5 at $5 / $25, that is 20% off input and 20% off output (our arithmetic). The cache-hit row moved considerably further: Opus 5’s cache hit was $0.50, Opus 5.5’s is $0.20, a reduction of 60% (our arithmetic). The page does not state an effective date, so we cannot tell you when this took effect, only that it was not on the page on 22 September and was on 23 September.
The footnote is the actual news
Underneath the table sits a single sentence: “Cache hits and refreshes on Claude Opus 5.5 are priced at 0.05x the base input price.”
Until recently Anthropic’s cache multiplier was a constant you could carry in your head: cache hits cost one tenth of the input price. There are now three values in circulation on the same price list — the standard 0.1x, the 0.025x that applies to Fable and Mythos 5.1, and this new 0.05x on Opus 5.5.
The consequence is quick to state and slow to notice: the cached-input price is no longer derivable from the input price. Any spreadsheet, internal cost model, or finance dashboard that computes a cache-hit column as input multiplied by 0.1 is now producing a wrong number for at least two Anthropic models, in opposite directions, and it will keep producing it silently, because the formula still runs and still returns a plausible figure. This is the third time this year we have had to write down a version of the same sentence: the thing that broke was not the price, it was a relationship between prices that everyone had quietly promoted to a law.
The $0.20 line
Sonnet 5 is $2 input at the standard 0.1x, which gives a cache hit of $0.20. Opus 5.5 is $4 input at 0.05x, which gives a cache hit of $0.20. The two are identical to the cent (our arithmetic on the two published multipliers).
That is not a rounding coincidence you can ignore, because of the shape most coding-agent workloads actually have. A long session re-reads a large, stable context every turn: the system prompt, the file tree, the open files, the conversation so far. Those tokens are cache hits. The genuinely new tokens each turn are a small fraction. On that shape, the dominant input line item now costs exactly the same whether you are running Sonnet 5 or Opus 5.5.
Worked through: take a turn that reads 1,000,000 input tokens of which 950,000 are cache hits and 50,000 are fresh. Sonnet 5 costs 0.95 x $0.20 + 0.05 x $2.00 = $0.29. Opus 5.5 costs 0.95 x $0.20 + 0.05 x $4.00 = $0.39 (our arithmetic). The headline input prices differ by 100%; the bill on this workload differs by 34%. Output still differs by the full 2x ($10 against $20), and cache writes are billed separately at rates we have not re-read for Sonnet 5 today and therefore do not quote here.
The practical reading: the “Opus is twice the price of Sonnet” heuristic was roughly true when cache hits were 0.1x on both. It is now wrong in the direction that matters, and the size of the error depends on your cache-hit rate — a number that is in your own logs and on nobody’s price list.
What GPT-6 Sol and Luna did to the Codex side
New rows on the rate card, in credits per million tokens, as input / cached input / output:
- GPT-6 Sol: 50 / 5 / 250
- GPT-6 Luna: 2.5 / 0.25 / 12.5
- Also new, and not previously on this card at all: GPT-Image-2 (image) at 200 / 50 / 750 and GPT-Image-2 (text) at 125 / 31.25 / 250
GPT-6 Sol’s input rate of 50 is exactly half GPT-5.6 Sol’s 100. GPT-6 Luna’s 2.5 is exactly half GPT-5.6 Luna’s 5 (our arithmetic). A new footnote states that “GPT-5.6 Sol, Terra, and Luna rates remain unchanged.”
Those two facts together are the whole story: nothing you are currently running got cheaper. A successor generation arrived at half the rate of its namesake, and the saving is available only to accounts that move to it. That is a different event from a price cut, and it should be filed differently — a price cut arrives whether or not you do anything, a successor tier arrives only if you go and get it.
The usage table gained matching rows, in local messages per five hours: GPT-6 Sol on Plus 15–150, Pro 5x 70–700, Pro 20x 300–3,000; GPT-6 Luna on Plus 350–3,000, Pro 5x 1,750–14,000, Pro 20x 7,000–56,000. The Plus card now reads “GPT-6 Sol and GPT-6 Luna”.
The Free and Go cards were rewritten to “GPT-6 Luna at Standard speed in the desktop app, subject to rollout” — the first time a GPT-6 model has appeared on the free card at all. The qualifier is doing real work: the date on which any particular account actually sees it is officially not published, so “available on Free” is true of the product and not yet necessarily true of you.
The Fast mode sentence also widened, from naming GPT-6 Astra alone on 22 September to “Fast mode uses 2.5x the Standard credit rate for GPT-6 Astra, Sol, and Luna where available.”
We do not convert credits into dollars anywhere on this site. OpenAI publishes no credit-to-USD conversion on this page, and a conversion we invented would look exactly as authoritative as one we did not.
The comparison the units still allow: ratios
One vendor prices in US dollars per million tokens. The other prices in credits with no published conversion. Laying the two rate cards side by side produces a table that looks like a comparison and is not one. But ratios inside each vendor are unit-free, and those do survive the crossing.
- Cached input as a share of input. OpenAI: 10% on both new models (5/50 and 0.25/2.5). Anthropic: 10% as standard, 5% on Opus 5.5, 2.5% on Fable and Mythos 5.1. One vendor holds a constant; the other has made it a per-model attribute.
- Output as a multiple of input. GPT-6 Sol: 5x. GPT-6 Luna: 5x. Opus 5.5: 5x. Sonnet 5: 5x. All four identical (our arithmetic).
- Fast-mode premium. Anthropic’s Opus 5.5 fast mode at $8 / $40 over a base of $4 / $20 is 2x on both rows. OpenAI states 2.5x the standard credit rate.
- Successor discount. Half, at both vendors, this week.
Read down that list and something slightly uncomfortable emerges: the two products agree on almost every ratio that is visible. The 5x output multiple is the same. The successor halving is the same. They differ in exactly two places — the cache discount, where Anthropic has begun varying a number OpenAI holds fixed, and the fast-mode premium, where the gap is 2x against 2.5x.
Which means the honest summary of this week is: when the shapes agree this closely, the remaining difference is the unit, and the unit is the one thing neither page lets you convert. Anyone publishing a confident “X is N times cheaper than Y” this week is either quoting a conversion rate they made up, or comparing a dollar to a credit and hoping nobody checks the column headers.
Still true, still odd
- GPT-5.4, GPT-5.4 mini and GPT-5.5 remain listed in both the usage table and the rate card despite being deprecated. This is the fourteenth consecutive day we have recorded that.
- The notice that GPT-5.5 retires from Codex on 14 October 2026 is still at the top of the page. If your tooling pins that model, the calendar is now the binding constraint, not the price.
- The Sol promotion runs “at least through November 21, 2026”. That is a floor, not an expiry — it tells you the promotion will not end before that date and nothing about when it will.
- Neither page carries an effective date for this week’s additions. We date our own reading instead, which is why every figure above is stamped 23 September 2026.
What to actually do about this
- Get your cache-hit rate out of your logs. Without it, the Sonnet-versus-Opus decision is being made on a headline ratio that this week stopped being true. With it, the decision takes one line of arithmetic.
- Grep your cost model for a hard-coded 0.1. If a cache-hit column is computed rather than quoted, it is now wrong for two Anthropic models and will not tell you so.
- Treat the GPT-6 rows as an opt-in, not a discount. Nothing you are running today changed rate. The halving only reaches accounts that move.
- Stop comparing the two sides by number. Compare them by ratio, which is legitimate, and by the operational limits in the usage table, which are stated in the same unit at both vendors — messages per window. We keep the current usage figures in our Codex usage limits page.
Related reading on this site: the cross-vendor rate tables, including DeepSeek’s newly readable price list and the time-of-day multiplier attached to it, are maintained on our AI coding assistant pricing page. If you are weighing a subscription against a metered API rather than one vendor against another, that comparison lives on GLM Coding Plan vs Claude Code, which this week also picked up DeepSeek’s official Claude Code configuration.
Update, 24 September 2026: both rate cards now have an appendix, and the sentence this page relied on is no longer on Anthropic’s
Nothing either vendor charges changed today. One thing each vendor says did, and on this page that matters more than usual, because this page has quoted one of those sentences five times.
The correction first
This comparison has stated that Anthropic explicitly cancelled a previously scheduled increase to $3 and $15 per million for Sonnet. When we wrote that, the sentence was on Anthropic’s official pricing documentation. It was still there when we read the page on 23 September 2026. On 24 September 2026 it is gone.
Every price on that page is unchanged. Sonnet 5 remains $2 input and $10 output per million with cached input at $0.20. Opus 5.5 remains $4 and $20 with cached input at $0.20 and its 0.05x footnote. The 1.1x regional multiplier, the long-context provision and the tokenizer note are all still published. Nothing this page tells you about what you will be billed has become wrong.
What has become unverifiable is narrower: we told you the increase had been cancelled, citing a sentence that is no longer there to check. We are leaving the earlier passages in place with this note attached rather than editing them out. A comparison site that silently revises its own back catalogue is asking you to trust a record it has been quietly maintaining, and we would rather carry a visible correction than an invisible one.
We are not predicting a price rise, and we would treat anyone who does today as guessing. A cancellation note is exactly the kind of prose a vendor deletes during a page redesign once it has served its purpose — and this page was redesigned on the same day. That reading and the alarming one fit the available evidence identically, and the available evidence is a single missing paragraph. Budget against $2 and $10, because that is what is published and what you will be charged.
Both rate cards have now split into a headline tier and an appendix, for opposite reasons
The other half of today’s change on Anthropic’s page is structural: the rate table now shows four highlighted models, with everything else moved into a section headed “Additional models”.
That is worth putting next to something we have recorded on the OpenAI side fifteen times: models announced as deprecated are still sitting on the Codex rate card. The two vendors have arrived at the same two-class structure from opposite directions. Anthropic demoted current models into an appendix. OpenAI kept retired models on the main card. One page makes live options look peripheral; the other makes dead options look live.
The shared consequence for anyone choosing between them is that position on a rate card has stopped being evidence of anything. A model in the appendix is not necessarily older, cheaper or on its way out, and a model on the front page is not necessarily the one you should be routing to. Both facts are now editorial decisions about a documentation page rather than statements about the product line, and neither page tells you which it is doing.
This joins a pattern we keep running into from different angles this month. Deprecated models outlive their deprecation on the rate card. Retired model names outlive the models, pointing at new routing and new prices. Now current models get filed under “additional”. In all three cases the string in your config and the layout of the vendor’s page have come loose from what you are actually running and what you are actually paying. The only reliable sources left are the response metadata and the bill.
The general lesson, which is portable and cheap to act on
A pricing page is two documents sharing a URL. One is a table of numbers, maintained carefully because customers check numbers. The other is prose: the commitments, the reassurances, the promotional end dates, the “subject to rollout” qualifiers, the sentences that say a thing will not happen. Numbers get changelogs. Sentences get deleted. There is nothing in how documentation is published that treats removing a paragraph as an event, so it leaves no trace at all.
Both vendors compared on this page have prose your budget might be resting on right now. A promotional rate described as holding “at least through” a date — a floor, incidentally, not an expiry. A deprecation scheduled for 14 October. A free-tier model listed as available “subject to rollout”, with no stated arrival date. None of that is in a table. All of it can be revised by someone editing a paragraph.
So: archive the paragraphs, not just the tables. Screenshot or save the vendor sentences your plan depends on, with the date you read them. It takes ten minutes and it produces the only copy that will still exist if the vendor changes its position. We can tell you today what Anthropic’s page said yesterday for exactly one reason, which is that we wrote it down with a date on it.
What to do this week
- Budget Anthropic at $2 and $10 per million for Sonnet 5. Published today, unchanged today. Any line in your model for $3 and $15 was always speculative; it has simply lost the vendor sentence that was holding it down.
- Stop reading rate-card position as a signal. Check the model you are routing to on its own merits, because “highlighted” and “additional” are now page-design decisions on one side and “still listed” means “already deprecated” on the other.
- Archive the vendor paragraphs your budget depends on, with dates. Promotional floors, deprecation dates, rollout qualifiers. Ten minutes, once.
- Keep 14 October on the calendar for the Codex-side retirement, and treat the promotional rate as a floor with no announced end rather than a rate with a known expiry.
For the full cross-vendor rate tables, including today’s Kimi K3 cache-write tiers and why its five-minute cache costs exactly what sending the tokens would have cost, see our AI coding assistant pricing comparison. For the four vendors now offering documented ways to run Claude Code against something other than Anthropic — and the four mutually inconvertible units they bill in — see our comparison of the GLM coding plan against Claude Code. And for how the Codex side’s own limits and rate tiers actually work in practice, see our guide to Codex usage limits.
All prices are vendor list prices read on 24 September 2026. Figures identified as our arithmetic are our own calculations on published numbers, not vendor claims. Where a vendor does not publish a figure we say so rather than estimating it.