Codex vs. Claude Code: The Real Cost Comparison (2026)

Codex and Claude Code are two of the leading AI coding agents, but comparing their cost isn’t as simple as looking at the monthly subscription price. Both start around the same price point, yet they differ significantly in how usage is metered, how quickly limits are reached, and what you ultimately pay to complete real coding work.

This guide breaks down Codex vs. Claude Code pricing in 2026, from subscription tiers and API rates to rate limits, cost per task, and what each option looks like at engineering-team scale.

Codex vs Claude Code

Both are AI coding agents that live inside a subscription you're probably already paying for, and both have a genuinely free way in for light use. But the two default to different work styles, and that difference is what actually drives cost.

Codex is a background agent first. It runs inside ChatGPT — on the web, in the CLI, in an IDE extension, or as a task delegated straight from a GitHub pull request — and its native mode is to pick up a scoped task, work through it (often in the cloud, unattended), and come back with a diff. Claude Code is a terminal-first agent. It lives in your shell, and it's built around long interactive sessions where you're steering it turn by turn as it runs.

That distinction shapes how each product meters usage, which is the real reason the pricing comparison isn't as simple as it looks. Codex bills primarily on task and message volume inside a rolling five-hour window, and which model you pick — Sol, Terra, or Luna — determines how fast that allowance burns down. Claude Code bills on token consumption inside the same five-hour and weekly windows that also cover your regular Claude.ai usage, so a heavy day of chatting with Claude eats into the budget you have left for coding.

Both companies also made the same structural choice: neither sells its coding agent standalone. There's no Codex-only plan and no Claude-Code-only plan — you're buying a ChatGPT or Claude subscription, and the coding agent is one of the things bundled into it. That bundling is exactly why “$20 vs. $20” undersells the real comparison. The fine print about what each tier actually includes, and how quickly you can burn through it, is where the cost difference actually shows up — and that's what the rest of this piece works through.

Codex vs Claude Code Pricing: The Short Answer

Here is every tier of both products, plus API pricing, as of September 2026:

Table 1: Subscription tiers, Codex and Claude Code. Sources: OpenAI's Codex/ChatGPT pricing page and Anthropic's Claude pricing page, checked September 11, 2026. Both vendors update these pages without notice — verify before publishing a budget against them.

And the API rate card both products draw on when you go the pay-per-token route instead of a subscription:

Table 2: Per-model API pricing, per million tokens. Sources: Anthropic's and OpenAI's official API pricing pages, checked September 11, 2026.

Six things worth pulling out of those tables before going further:

• Entry price is identical. The cheapest tier that gets you real coding features on either product is $20/month — Plus for Codex, Pro for Claude Code — assuming you don't count OpenAI's $8 Go tier, which is local-only and excludes cloud task delegation.
• Both mid-tier jumps land at exactly $100/month. Codex Pro 5x and Claude Max 5x charge the same price for the same 5x usage multiplier over their respective entry tier.
• Both top individual tiers cap at $200/month. Codex Pro 20x and Claude Max 20x are priced identically at the ceiling.
• Team entry pricing is broadly comparable. Claude Team Standard includes Claude Code at $20–$25/seat, while Premium raises usage limits substantially at $100–$125/seat. Codex Business also includes Codex at $20–$25/user.
• Flagship API rates are close but not identical. Claude Sonnet 5 ($2/$10 per million input/output tokens) and GPT-5.6 Terra ($2/$12) sit within two dollars of each other. At the top end, Claude Opus 5 ($5/$25) beats GPT-5.6 Sol's promotional rate ($4/$20) on output but costs more on input.
• Both vendors are mid-cycle on price changes. Anthropic cancelled a scheduled Sonnet 5 price increase in August 2026, making $2/$10 the standing rate rather than a temporary one. OpenAI's Sol promotional rate is scheduled to hold only through November 21, 2026 unless extended. Recheck both before locking in a year-end budget.

The headline prices are the easy part. The next section covers how those tiers actually translate into daily coding capacity — and where the two products' usage models diverge enough to change which one is cheaper for your specific workload.

How Each Product Charges

The headline prices tell you the entry cost. They don't tell you how fast you'll burn through what you bought — which is the number that actually decides whether a tier is enough.

Codex tiers and how they map to ChatGPT plans

Codex has no pricing ladder of its own. It's a feature bundled into whichever ChatGPT plan you're on, metered in local messages and cloud tasks inside a rolling five-hour window.

How fast that window empties depends on which model handles the message. OpenAI's four current models sit on a clear ladder:

• Sol — built for the hardest work; drains the allowance fastest
• Terra — the “everyday workhorse” for production tasks
• Luna — tuned for high-volume, low-stakes work; stretches furthest
• GPT-6 Astra — added September 2026; the new flagship, above Sol

OpenAI publishes ranges rather than fixed counts, since a small script and a long refactor don't cost the same number of messages:

Table 4: Local messages per rolling 5-hour window, by model and plan. Source: OpenAI's Codex pricing page, checked September 11, 2026. Pro 5x and Pro 20x multiply the Plus range by 5 and 20 respectively; Business seats get the Plus allowance, per seat.

Once you run out mid-task, Plus and Pro users can buy extra credits rather than being cut off — the agent finishes the turn you're on, and overage draws down a credit balance billed at OpenAI's standard per-token rate.

Claude Code tiers and how usage is shared across surfaces

Claude Code doesn't get its own allowance. It draws from the same token budget as your regular Claude.ai chat usage, inside the same five-hour session window plus a separate weekly cap Anthropic added to stop unattended, 24/7 background usage.

A heavy afternoon of chatting with Claude eats into the budget you have left for coding that evening. Codex doesn't have that problem — ChatGPT chat usage and Codex usage are metered separately.

Anthropic also doesn't publish a fixed token or message count for any tier, only a multiplier: Max 5x is 5x Pro's usage per session, Max 20x is 20x. Real capacity still depends on the model — an Opus 5 session burns the shared budget faster than a Sonnet 5 session.

API pricing for both, and when you would use it instead

Both products offer a second path that skips the plan ladder entirely: bring your own API key, pay per token, no five-hour window, no weekly cap, no reset to wait for.

The trade-off is the same on both sides — an API key loses the cloud-hosted conveniences. Codex loses GitHub-integrated code review and Slack integration; Claude Code's API path loses the equivalent cloud features. Table 2 has the current per-token rates for both.

Use the API when:

• You're automating something — CI/CD, scheduled jobs, batch work
• The workload is bursty and unpredictable
• You want exact, predictable per-unit cost, with nobody waiting on a rate-limit reset

Use the subscription when:

• Work is interactive and in-the-loop
• A flat monthly fee beats metering every keystroke

Several independent estimates put Claude Code's break-even around 50 interactive sessions a month — below that, API billing is cheaper; above it, the subscription wins.

What “5x” and “20x” tiers actually mean in practice

Both vendors sell their upper tiers as a multiplier, not a hard number — and it's worth being precise about what that multiplier is relative to. “5x” and “20x” mean usage headroom over the tier directly below (Plus for Codex Pro, Pro for Claude Max), not a fixed token count.

Codex at least makes this concrete — see Table 4 above. Anthropic doesn't publish the equivalent numbers for Claude Code, so the only reliable way to know which multiplier you need is empirical: how many agent sessions you run at once.

One terminal, one session at a time, rarely exhausts Pro. Three or four sessions running in parallel across different projects burn a five-hour window three or four times faster, because each session independently reads files, calls tools, and reasons. Size a Max plan by how many agents you run side by side — not by how many hours you personally work.

The Real Cost Metric: Price Per Completed Task

Every comparison of these two tools eventually publishes a benchmark score. Almost none attach a dollar figure to it. This section closes that gap — not which model scores higher, but what it costs to get a working result out of each one.

Why cost per token is the wrong measure

Per-token pricing is the number everyone compares first. It's the wrong one to optimize for alone — it says nothing about how many tokens a task actually takes to finish.

The clearest illustration is sitting in the current data: Claude Fable 5.1 and GPT-6 Astra are priced identically — $10 input / $50 output per million tokens, to the dollar.

If cost per token were the whole story, running either through its native harness would cost the same per completed task. It doesn't:

• Claude Fable 5.1 in Claude Code: $12.39 per task
• GPT-6 Astra in Codex: $7.47 per task

A 40% gap, entirely because Claude Code's harness uses roughly 70% more tokens to reach the same result (5.7M vs. 3.3M per task). Identical sticker price, materially different real cost.

This is Artificial Analysis's own framing, not just an inference from the rate card — see their GPT-6 Astra benchmarking writeup.

Token efficiency vs task success rate — the trade-off that decides real cost

Token efficiency cuts both ways once you widen the comparison past the flagship models:

Table 5: Budget-tier model variants, same benchmark run. Source: artificialanalysis.ai, checked September 11, 2026. Compare to ~62 for the flagship pairings in Table 3.

Both budget options score far lower on the Coding Agent Index than the flagship pairings (62). A benchmark's cost-per-task figure reflects one attempt at a fixed task set — it doesn't price in what happens after a lower-scoring model turns in a worse first draft: the review time, the follow-up prompts, the rework.

A model that's 90% cheaper per task but needs meaningfully more human correction isn't actually cheaper once that time is counted. “Cheapest per task” and “cheapest to actually ship” aren't the same ranking.

Published figures from independent testing

The most current independent numbers come from Artificial Analysis's Coding Agent Index (v1.5), a composite of three benchmarks — DeepSWE v1.1, Terminal-Bench 4.0, and SWE-Atlas-QnA — that scores coding-agent harness-and-model combinations rather than models in isolation, and separately reports cost, time, and token usage per task. It's a living index that gets rebuilt as both companies ship new models, so treat the figures below as a dated snapshot, not a permanent scoreboard:

Table 3: Artificial Analysis Coding Agent Index v1.5, head-to-head and next-tier model variants. Source: artificialanalysis.ai, checked September 11, 2026. Cost per task reflects pay-per-token API pricing on Artificial Analysis's benchmark task set — not consumer subscription pricing, and not production supervision or review time.

At the flagship tier, the two agents tie on Coding Agent Index score (62), with Claude Code's Fable 5.1 configuration slightly ahead on two of three underlying benchmarks (Terminal-Bench 4.0, SWE-Atlas-QnA) and Codex's GPT-6 Astra ahead on the third (DeepSWE v1.1). Codex reaches that tied score faster (29.4 minutes vs. 34.8) and cheaper ($7.47 vs. $12.39).

Where each product is genuinely cheaper

At the frontier tier — where most serious engineering work happens — Codex is the cheaper way to reach the same independently-measured quality. GPT-6 Astra and GPT-5.6 Sol both undercut Claude Code's flagship configs on cost per task while landing at or near the same Index scores.

At the budget end, Codex's routing to third-party open-weight models reaches lower price points than anything Claude Code offers in this benchmark run — DeepSeek V4 Flash at $0.08/task — though at a steep quality cost that limits it to routine, low-stakes work.

None of that is the whole picture: it's pay-per-token API cost on a fixed benchmark task set, not what either tool costs on your actual subscription plan. Next: what happens when you're not paying per token at all, but living inside a five-hour window and a weekly cap instead.

Rate Limits: The Hidden Half of the Price

Every tier ends somewhere. What happens at that edge, and how expensive it is to avoid, is the part of the pricing story most comparisons skip.

What actually happens when you hit a limit on each

Codex is the more forgiving of the two. Mid-task, the agent finishes the turn you're on. After that, Plus and Pro users can buy additional credits to keep going without upgrading, switch to a cheaper model to stretch what's left of the window, or just wait for the five-hour reset.

Claude Code is blunter about it. Hit either the five-hour session limit or the weekly cap, and the session goes read-only — you can review what's already there, but you can't send a new prompt until the relevant window resets, you turn on usage credits at standard API rates, or you upgrade. Run /usage inside Claude Code, or check claude.ai/settings/usage, to see which of the two limits you actually hit and when it clears; the two have different causes, and switching models only helps with one of them.

Why heavy users end up on the higher tiers regardless of headline price

The $20 tier on either product isn't really built for someone running the agent most of the working day — it's built for a few focused sessions a week. Push it hard enough and you stop paying the sticker price on the tier below; you start paying that price plus interruptions, or buying credits to bridge the gap, or upgrading outright. All three tend to land near the same number, which is why heavy users converge on Max 5x or Pro 5x even though the entry tier is nominally $80–180/month cheaper.

Session-length and weekly-cap behaviour

Both products run a rolling five-hour window as the base unit, and both also have weekly usage limits.

Claude Code adds a second layer on top: a weekly cap shared across Claude chat, Claude Cowork, and Claude Code, aimed specifically at sustained, unattended, 24/7-style usage rather than ordinary daily work. It's the one that catches people mid-week — a five-hour reset does nothing for it, and only the weekly reset, a specific day and time shown in the error message, brings it back.

How to tell which tier you actually need before paying for it

Neither vendor publishes this as a lookup table, so the honest answer is to check your actual usage rather than guess:

• On Codex, the usage dashboard (chatgpt.com/codex/settings/usage) or /status in the CLI shows exactly how much of your window is left.
• On Claude Code, /usage (or claude.ai/settings/usage) shows the same for both the five-hour and weekly windows.

The number that actually predicts which tier you need isn't hours worked — it's how many agent sessions run in parallel. One session at a time rarely exhausts an entry tier on either product. Three or four running concurrently is what pushes people to Max 5x, Pro 5x, or higher.

Subscription vs API: The Arbitrage

Why subscriptions are dramatically cheaper than equivalent API usage

A Max 20x subscriber who actually uses the full session allowance can burn through the API-equivalent of $600–$1,500 a month in tokens for a flat $200, per one independent cost breakdown. That gap is the whole reason the subscription tiers exist: both vendors are selling a fixed amount of a variable-cost resource for a flat fee, on the bet that most subscribers won't use enough of it to make that a bad trade.

The same analysis puts Max 20x's break-even against pay-as-you-go API pricing at roughly 70 million tokens of typical Sonnet-heavy usage a month — comfortably more than a single developer generates in ordinary daily work, which is exactly why the arbitrage favors the subscriber at normal usage levels. Worth flagging: that's a third-party estimate, not a number Anthropic itself publishes, so treat it as directional rather than exact.

Why that gap is exactly why rate limits exist

Sell an unmetered $200/month product against real per-token costs, and the heaviest 1% of users would cost more than the other 99% pay for, combined. Rate limits are the mechanism that keeps the flat-fee tiers solvent — they let both vendors advertise usage that feels unlimited at a fixed price while capping the tail risk of someone actually running it unmetered around the clock. It's also why the weekly cap specifically targets sustained, automated-style usage rather than typical interactive sessions: it's aimed at the failure mode that would break the economics, not at ordinary daily work.

When API access genuinely makes more sense

Beyond the generic “automation” advice, four scenarios consistently favor API billing over a subscription seat:

• CI/CD and scheduled jobs, where nothing is waiting on a five-hour reset and a failed run at 2 a.m. needs to retry, not queue behind a rate limit.
• Bursty, unpredictable workloads — a pipeline that runs 50 tasks one day and zero the next doesn't fit a flat monthly allowance well either way.
• Anything you need to attribute or charge back by project, team, or customer, since per-token billing gives a clean unit of accounting that a shared subscription seat doesn't.
• Multi-agent or subagent-heavy workflows, which can add 200–500% token overhead versus a single agent doing the same task — overhead that's fine to absorb at API rates but can quietly blow through a shared subscription's five-hour window.

What This Costs a Whole Engineering Team

This is the section most comparisons skip, and it's the one that actually matters once you're buying for a team instead of yourself.

Seat math at 10, 50, and 200 engineers

Three purchasing paths, at three team sizes:

Table 6: Monthly cost by team size and purchasing path. Codex Business and Claude Team Standard are flat per-seat pricing from Table 1. Claude Enterprise combines the published $20/seat fee with Anthropic's own $150–250/developer/month usage estimate — an estimate, not a quote, and it will move with how your team actually uses the tool.

At smaller team sizes, Codex Business and Claude Team Standard are essentially identical on seat price. At larger scale, the purchasing paths diverge: Claude Team supports up to 150 seats, while Enterprise combines a seat fee with variable usage billed at API rates.

Mixing tiers by role rather than standardizing on one

Not everyone on a team needs the top tier. A more cost-effective default: reserve Max 20x or Pro 20x for engineers who genuinely run multiple parallel agent sessions or repo-wide refactors on a regular basis, put the rest of the team on the mid tier, and question whether non-engineering stakeholders — PMs, technical writers — need a coding seat at all versus occasional web access. Mixing tiers by actual usage pattern typically costs meaningfully less than standardizing everyone on whatever your heaviest user needs.

The API spend that sits outside seats when these tools run in CI/CD

Seats cover interactive, human usage. The moment either tool starts running headless — in CI, on a schedule, behind a bot account reviewing every pull request — that usage typically isn't covered by a seat at all. It's billed separately at API rates, against whatever project or budget the automation happened to be set up under.

That spend is easy to lose track of precisely because it doesn't show up on the same invoice line as your seats. In practice it usually gets attributed to whichever engineer wired up the pipeline, rather than tracked as its own line item — which is exactly how it goes unnoticed until it's large.

Forecasting and budgeting AI coding spend

Anthropic's own planning figures are a reasonable starting baseline for Claude Code specifically: an average of $13 per developer per active day, staying under $30/day for 90% of users, working out to roughly $150–250 per developer per month at typical enterprise scale. There's no equivalent public figure from OpenAI for Codex, which itself is worth noting — it's harder to benchmark a budget against a number nobody publishes.

The practical approach either vendor's own documentation recommends: start with a small pilot group, establish a baseline from actual usage before wider rollout, and use built-in tracking (the /cost command and Anthropic Console for Claude Code; the workspace analytics dashboard for Codex Enterprise) rather than the published averages alone, since real usage varies enormously by team and workflow.

Why this line item usually has no owner

Coding-agent spend tends to start on a company card or a small pilot budget, get adopted informally because engineers like it, and scale with headcount and enthusiasm rather than with a budget anyone actually approved for that number. Nobody owns it in the way someone owns cloud spend, because it didn't arrive through the process that usually assigns an owner.

Microsoft is the widely-reported cautionary case: engineers in one division adopted Claude Code enthusiastically enough that usage reportedly reached 84–95% of the group, and the tool was reportedly cancelled and replaced with an in-house alternative once token billing made the true cost visible — not because the tool underperformed, but because nobody had set a ceiling on it while it was still cheap to ignore. The specific $500–$2,000-per-engineer-per-month figure attached to that story comes from secondary industry coverage rather than Microsoft or the original reporting directly, so treat it as an illustration of the pattern rather than a confirmed number. The pattern itself generalizes past any one vendor: a coding agent that's actually useful will get used harder than a flat-rate mental model expects, and token billing has no ceiling unless a team sets one.

Which Should You Pick?

Everything above is inputs. Here's the output.

Pick Codex if...

• You want the cheapest route to frontier-quality output. GPT-6 Astra and GPT-5.6 Sol both beat Claude Code's flagship configurations on cost per task at the same or better Coding Agent Index score (Table 3).
• Your work arrives as well-scoped, already-spec'd tickets a background agent can pick up and finish without anyone watching it happen.
• Your team already collaborates through GitHub, and you want PR review and CI delegation built in rather than bolted on.
• You need a genuinely cheap tier for high-volume, low-stakes work — Luna's $0.20/$1.20 per-million-token rate has no real equivalent on the Claude side.

Pick Claude Code if...

• Your work is repo-wide refactors or “figure out why this broke” investigations that benefit from a long, steered, interactive session rather than a fire-and-forget task.
• You want full local terminal and filesystem control — watching and redirecting the agent turn by turn instead of reviewing a diff after the fact.
• Your team already pays for Claude subscriptions for other work (chat, Cowork), and coding usage can fold into that same pooled allowance rather than buying a second tool.
• Terminal-Bench and SWE-Atlas-QnA-style tasks matter more to your work than raw task throughput — Claude Code's flagship configuration edges out Codex on both, even at a cost premium.

When running both is actually the cheaper answer

Running both isn't redundant spend if you split by task type rather than by team. Well-specified tickets and CI-style scripting go to Codex, where per-task cost is lowest and nobody needs to watch it work. Repo-wide refactors and ambiguous debugging go to Claude Code, where the interactive format pays for itself in fewer follow-up prompts.

Some teams push this further and use one to review the other's output — pointing Codex at Claude Code's pull requests, for instance — on the logic that a second model catches a different class of mistake than the one that wrote the code. At the $20 tier specifically, running both costs the same $40/month as many individual “power user” tiers cost on either product alone, which makes it a reasonable default for a two-tool team rather than a luxury.

Whichever tool you land on, the harder problem is the one this piece keeps surfacing: AI coding spend behaves more like cloud spend than a simple per-seat SaaS bill. It scales with usage, can spread across subscriptions, API consumption, and the infrastructure supporting AI workloads, and often grows faster than teams expect.

As AI becomes a larger part of engineering spend, that makes broader cost visibility and governance increasingly important. nOps helps teams understand and optimize cloud and AI infrastructure costs across AWS, GCP, and Azure — so they can see what’s driving spend, allocate costs to the teams and workloads responsible, and identify opportunities to reduce waste.

• Unified visibility: Understand cloud and AI infrastructure spend across teams, applications, customers, and business units with granular cost allocation.
• Commitment Management: Automatically maximize discounts and minimize commitment risk across eligible cloud infrastructure supporting your AI workloads. Customers typically save ~20% by switching to nOps — and with results-based pricing, you pay only when you get better results.

nOps manages $5B+ in cloud spend and was recently rated #1 in G2's Cloud Cost Management category. Get a free savings analysis to see where your cloud and AI infrastructure costs can be optimized.

Demo

AI-Powered Cost Management Platform

Discover how much you can save in just 10 minutes!

Book a Demo

FAQ