OpenAI Codex Pricing in 2026: Every Plan From $8 to $200/mo

OpenAI Codex costs anywhere from $0 to $200 per month as of July 2026, and since April 2, 2026 every plan meters usage with token-based credits worth about $0.04 each. That restructure is why "codex pricing" keeps spiking in search: the old per-message limits are gone, and your bill now depends on which model you pick and how many tokens each task burns.

Here is the part the official pages will not do for you: the arithmetic. OpenAI publishes a rate card in credits per million tokens, but nobody hands you the answer to the question you actually have — what will my month cost? This guide does that math: every plan from Go at $8 to Pro at $200, the exact credit rates, what a bug fix versus a repo-wide migration burns, what light, moderate, and heavy months really cost, how Business and Enterprise billing works after the June 24 seat change, and when a flat-priced alternative is simply cheaper.

OpenAI Codex pricing is a token-metered credit system layered on ChatGPT subscriptions: every tier from Free to Pro 20x ($200/month) buys a differently sized rolling 5-hour allowance of credits worth about $0.04 each — so your real monthly cost depends on tokens burned, not tasks completed.

TL;DR: OpenAI Codex is bundled into ChatGPT plans: Free $0, Go $8, Plus $20, Pro $100/$200, Business $20/user/mo billed annually. Since April 2, 2026 it meters usage with API-aligned credits (~$0.04 each) on a rolling 5-hour window; a typical session costs $0.50–$2.00 and heavy users land near $100–200/month. Taskade Genesis is the flat alternative: Free, then $10/$25 billed annually. Start free →

Last updated: July 27, 2026 — added the June 24 Business Codex-seat cutoff, GPT-5.5 Cyber and fast-mode rates, per-model window limits, worked monthly cost models for three usage profiles, and refreshed Claude Code, Cursor, and GitHub Copilot comparisons (Copilot moved to token-based AI Credits on June 1, 2026).

How Much Does OpenAI Codex Cost?

As of July 2026, OpenAI Codex costs $0 to $200 per month for individuals: Free, Go at $8/month, Plus at $20/month, and Pro at $100/month (5x capacity) or $200/month (20x). Teams pay $20 per user/month on annual billing ($25 month-to-month, 2-seat minimum) for Business, and Enterprise/Edu is contact-sales. Every tier meters Codex with token-based credits that refill on a rolling 5-hour window, so the plan you buy determines how big that window is, not a fixed number of tasks.

The ranges are wide on purpose. A "message" is not a fixed unit anymore: a one-line question burns a few credits while a long agentic run with a big context can burn dozens, so the same plan supports 15 heavy messages or 80 light ones in the same window.

If you want a single planning number: hobbyists fit inside Free or Go ($0–$8), a working developer fits Plus ($20) until they hit the window regularly, and the all-in cost of a heavy Codex habit converges on $100–200/month, whether you buy it as a Pro subscription or accumulate it through Business usage. Here is the identity card for the whole system:

The plan family tree makes the structure obvious — three lanes, and every lane meters the same credits:

One structural takeaway before the details: the individual lane is linear (each step buys roughly proportional window capacity), the team lane is a pool, and the enterprise lane is a negotiated contract. Which lane you are in matters more than which tier.

Pricing Timeline: What Changed on April 2, 2026

On April 2, 2026, OpenAI replaced Codex's per-message metering with API-token-aligned credits. Before the change, every Codex task counted as one message against your plan's cap, whether it was a typo fix or an hour-long agent run. After it, each task draws credits proportional to the actual tokens consumed, at the same effective rates the OpenAI API charges.

The practical effect: small tasks got cheaper, big agentic runs got more expensive, and model choice suddenly matters. It also means you can now reason about Codex costs the same way you reason about API costs, which is exactly what the rest of this guide does.

April 2 was not the only date that matters, though. The first half of 2026 rewired Codex billing in four distinct steps, and two of them change what teams should buy today:

The takeaway from the timeline: OpenAI spent Q2 2026 converting Codex from a bundled perk into a metered utility, then narrowed the ways teams can buy it à la carte. If you are budgeting for the rest of 2026, assume the credit model is permanent and plan around consumption, not seats. For the fuller product backstory, see the complete OpenAI Codex history and the broader OpenAI and ChatGPT story.

Why Did OpenAI Move Codex to Credits?

Because the old system charged a typo fix and an hour-long agent run the same price, and agentic use broke that math. Under per-message metering, one "message" could quietly consume a thousand times the compute of another — fine when Codex answered questions, unsustainable once it started running multi-step agent sessions that read entire repositories. Token credits make the price track the cost: heavy tasks pay more, light tasks pay less, and the meter finally measures the thing that actually costs OpenAI money.

Three second-order effects of the change are worth understanding, because they explain most of what confuses people about the current pricing:

• Model choice became a pricing decision. Before April 2, picking GPT-5.5 over GPT-5.4-mini changed quality, not cost. Now it changes your bill by a factor of about seven. That is deliberate: it pushes routine work onto cheaper capacity and reserves the frontier model for tasks that earn it.
• The plan tiers stopped being usage promises and became window sizes. "15–80 messages" is not a quota, it is an exchange rate between your plan and your task weight. The wide ranges that frustrate people are honest — a plan genuinely cannot promise a task count when tasks vary 100x in size.
• Subscription and API pricing fused into one system. With credits aligned 1:1 to API token prices, arbitrage between the two disappeared. The only remaining difference is packaging: the subscription bundles discounted consumption behind a window, the API sells unmetered consumption at list price.

The same logic swept the category within a quarter — GitHub Copilot's June 1 move to AI Credits followed the identical playbook — because every vendor faced the same asymmetry between chat-era pricing and agent-era costs. The agents vs copilots divide explains why agentic workloads forced the issue everywhere at once.

What it means for you: the era of "unlimited AI coding for $20" is over industry-wide, and the winners under credit pricing are people who route models deliberately and keep sessions warm. The rest of this guide is effectively a manual for being one of them.

How Much Do Codex Credits Cost?

One Codex credit is worth about $0.04, and every model has a published credit rate per million tokens that maps 1:1 to OpenAI's API prices. As of July 2026, the rate card looks like this (credits per 1M tokens):

Two patterns to internalize. First, output tokens cost about six times input tokens on GPT-5.5 and GPT-5.4 (closer to eight times on GPT-5.3-Codex), so tasks that generate lots of code cost far more than tasks that mostly read it. Second, cached input is ten times cheaper than fresh input, so continuing an existing session with warm context is much cheaper than cold-starting the same conversation. The specialist GPT-5.5 Cyber tier sits at 4x standard GPT-5.5 rates — reserve it for the security-review work it is built for, not everyday edits.

Why is the per-message range so wide? Context. A message's input tokens include everything Codex re-reads: the files in scope, the conversation so far, and tool outputs along the way. A question about one function might send 20K tokens; an agent run across a large repository can send hundreds of thousands. And because cached input bills at a tenth of fresh input, the same context costs far less the second time it is sent, which is why the first message of a session is often the most expensive one.

The credit pipeline, end to end:

Here is what that means in dollars for real work:

Run those numbers forward and the monthly picture emerges: a developer doing two or three sessions a day lands around $30–$120 of raw credit consumption per month, and OpenAI's own guidance for heavy users pegs real-world spend at roughly $100–200 per developer per month. That is why the Pro tiers exist: the $200 plan is priced at approximately what a heavy user would otherwise consume.

   CODEX CREDIT MODEL (since Apr 2, 2026)
   ┌───────────────────────────────────────────────────┐
   │  1 credit ≈ $0.04, aligned to API token prices    │
   │  rolling 5-hour window  ──►  credits refill       │
   │                                                   │
   │  GPT-5.5 message     ≈ 5–45 credits ($0.20–1.80)  │
   │  small bug fix       ≈ 10 credits   (~$0.40)      │
   │  multi-file refactor ≈ 60 credits   (~$2.40)      │
   │  typical session     ≈ $0.50–$2.00                │
   │                                                   │
   │  ✗ no per-task estimate shown up front            │
   │  ✗ no user-set spending ceiling                   │
   │  ✗ no flat unlimited plan below Enterprise        │
   └───────────────────────────────────────────────────┘

The cache discount is the single most underused lever in the whole system. Re-sending a 100K-token context costs 12.5 credits fresh on GPT-5.5 but only 1.25 credits cached — a 90% saving for simply staying in the same session instead of opening a new one:

Takeaway: batch related work into one long session. Ten follow-up questions inside a warm session can cost less than two cold-started ones.

How Do Codex Credits Burn by Task Type?

The rate card tells you credits per million tokens; it does not tell you what a task costs, because tasks differ in shape. Here is the arithmetic, worked openly so you can adapt it: estimate input tokens (everything Codex reads), estimate output tokens (everything it writes), apply the rate card, and multiply by $0.04. These are our estimates from the published rates, not OpenAI figures — but the method is exactly how the meter works.

Walk through one row so the method is clear. A multi-file refactor sends roughly 200K input tokens: 200,000 × 125 credits ÷ 1,000,000 = 25 credits of input. It writes about 25K output tokens: 25,000 × 750 ÷ 1,000,000 ≈ 19 credits. Add re-reads, tool calls, and a retry or two and you land in the 45–70 credit range — $1.80 to $2.80. That matches OpenAI's own "~60 credits" refactor example almost exactly, which is a good sanity check that the method is right.

Three planning rules fall out of this table:

• The 7x model spread is real money. The same migration costs about $6 on GPT-5.5 and under $1 on GPT-5.4-mini. Route mechanical work (renames, test scaffolding, boilerplate) to the mini model and save the frontier model for design decisions.
• Output-heavy tasks are the budget killers. Generating a large new module costs disproportionately more than reviewing one, because output bills at six times input. Ask for diffs, not full-file rewrites.
• Agent runs compound. An autonomous run is many messages in a trench coat: every tool call re-reads context. The 60% cache assumption in the migration row is generous — a poorly scoped agent run that keeps cold-starting can double it.

One more line item to know about: cloud tasks run in managed containers, and independent guides published in May 2026 measured container fees of roughly $0.03–$1.92 per 20-minute cloud session depending on machine size, while local CLI tasks carry no container fee. Treat that as third-party measurement rather than an official rate, but budget a small premium for cloud-heavy workflows.

What Does a Real Week of Codex Credits Look Like?

Here is a plausible working week for a full-time developer on Plus, assembled from the task table above — the kind of log OpenAI's dashboard shows you only after the fact:

Multiply by 4.3 and this developer consumes roughly 1,300 credits — about $52 of token value — in a month, on a $20 plan. That is the subscription working as designed: below the window, above face value. But notice the shape of the week. Thursday and Friday account for nearly two-thirds of the spend, and Friday's agent run alone costs more than the first three days combined. Credit budgets are not spread evenly; they are consumed in spikes, which is exactly why the 5-hour window (not the monthly total) is what you will actually feel. One bad Friday — an agent run that keeps cold-starting, or fast mode left on — can double the week without changing the calendar at all.

How Does the 5-Hour Window Work?

Codex credits refill on a rolling 5-hour window, not a monthly bucket or a midnight reset. Capacity recovers continuously: usage from five hours ago "ages out" of the window as new capacity becomes available. As of July 2026, the windows translate to these GPT-5.5 message ranges:

Model choice stretches the same window dramatically — the per-model limits published in mid-2026 guides show the full grid, and Business seats carry Plus-sized windows per user:

When you hit the limit, Codex pauses new requests until the window refills. Your options, in ascending cost order: wait it out, switch to a lighter model (GPT-5.4 draws half the credits of GPT-5.5, GPT-5.4-mini about a seventh), upgrade a tier, or on Business plans, buy a workspace top-up. The window is also why Codex sessions feel different from a monthly quota: you can never "save up" a month of credits for one massive weekend, but you also can never burn a whole month in one bad afternoon.

The window behaves like a state machine, and knowing the states helps you plan sessions instead of fighting the meter:

A concrete scenario: you start a Plus session at 9:00 a.m. and burn most of your window's capacity by 11:00. You are not locked out until 4:00 p.m. — the 9:00 usage starts aging out around 2:00 p.m., returning capacity in a trickle rather than a reset. Heavy mornings borrow from early afternoons. It also means two focused one-hour sessions spaced across a day feel roomier than one intense three-hour block, because the first session has partially aged out before the second begins.

Once you internalize the mechanic, you can schedule around it instead of colliding with it. Put the expensive work — agent runs, big refactors, anything on GPT-5.5 — at the start of your day, when the window is fresh and an unexpected throttle costs you the least. Push the cheap work (questions, reviews, mini-model tasks) into the hours after a heavy block, since light tasks fit into a depleted window that a refactor would not. And if you know a monster task is coming after lunch, deliberately keep the morning light: the window rewards people who alternate intensity the way interval training does. None of this changes what you pay — it changes how often you sit waiting, which for most Plus users is the real cost of the plan.

What Do Light, Moderate, and Heavy Codex Months Actually Cost?

A light month costs $8–$20 all-in, a moderate month $20–$100, and a heavy month $100–$400 — and you can predict which one you are heading for from two numbers: sessions per day and average task weight. This is the forecast OpenAI's pricing page will never publish, so here it is as a working model built on the verified rate card.

The line that matters is where your consumption value crosses your plan price. A moderate user consuming $60 of tokens inside a $20 Plus plan is getting 3x face value — the subscription is subsidizing them in exchange for accepting the window. A heavy user consuming $350 on Pro 20x is still ahead. The trap tier is the gap between them: consuming $110 of tokens on Plus means fighting the throttle daily, and that friction, not the dollars, is what pushes people up a tier.

Read the chart as: the line is what you consume (at ~$1.50 per session, 20 workdays), the bars are the plan you would realistically need at that intensity. One session a day fits Plus with room to spare; from three sessions a day the window pressure makes Pro 5x the honest choice; past six, you are a Pro 20x customer whether you like it or not.

Three worked months, end to end:

• Light month, freelancer on Go ($8): 60 tasks, mostly questions and small fixes on GPT-5.4 — about 250 credits, $10 of consumption value. Total cost: $8. The window never bites. The only reason to move to Plus is wanting GPT-5.5 as the default.
• Moderate month, full-time dev on Plus ($20): 40 sessions averaging $1.25 — $50 of consumption. Total cost: $20, and roughly 2.5x face value captured. Hits the window twice during a release week; downshifting to GPT-5.4-mini for test scaffolding absorbed it.
• Heavy month, agent-driven on Pro 20x ($200): daily multi-hour agent runs, 8,000 credits — $320 of consumption value for $200 flat. The subscription beats the API by $120, and the 300–1,600 message window is the difference between "runs all day" and "babysits a throttle."

Estimate your own month in one line: (sessions per week) × (average session cost from the task table) × 4.3. If that number is under $15, buy Go. Between $15 and $80, buy Plus. Over $80, price Pro 5x against it. Over $250, Pro 20x — or question whether every task needs a frontier model at all.

Is OpenAI Codex Free?

Codex is bundled into the ChatGPT free tier, so you can try it at no cost, but free usage is limited and metered like everything else. The cheapest paid step up is Go at $8/month, which buys a meaningfully larger credit allotment for occasional coding without committing to Plus. There is still no flat unlimited plan below Enterprise at any price.

Set expectations for what free actually covers: enough credits to evaluate the workflow — a handful of real tasks per window — but not enough to lean on daily. Free is a test drive, Go is a commuter car, and Plus is where full-time use starts. That is a reasonable ladder for a coding tool; just do not mistake the free tier for a free workload.

Codex Go vs Plus: Is $8 Enough?

Go at $8/month is enough for genuinely occasional coding — a few evenings a week of questions, small fixes, and short sessions — and not enough for anyone who opens Codex every workday. The dividing line from the worked models earlier: if your month burns under roughly 400 credits (about $16 of token value), Go covers it with margin; past that, you are rationing a window to save $12, which is a bad trade for anyone whose time bills at more than a few dollars an hour.

The honest budget sequence for a cost-conscious solo developer: start Free, move to Go the week the trial limits bite, move to Plus the week Go's window interrupts real work twice, and re-run the session math from the monthly-cost section before ever paying $100. Skipping steps costs more than it saves — most people who buy Pro 5x in month one would have fit inside Plus for half a year.

If "free" means build and publish a real app without a meter running, that is where a flat-priced builder fits better: Taskade Genesis has a genuinely usable Free plan — 6,000 AI credits (1,000 on verified signup plus 5,000 with your first build), 3 published Genesis apps, 1 AI agent, 3 automations, and basic project views — with no token metering and no 5-hour window. The two free tiers answer different questions: Codex Free asks "do you like this coding assistant?", Genesis Free asks "do you want this app to exist?"

What Is the Codex $200 Plan (Pro 20x) and Who Needs It?

The Codex $200 plan is ChatGPT Pro 20x: $200/month for twenty times Plus capacity — roughly 300–1,600 GPT-5.5 messages per rolling 5-hour window, up to 2,000 on GPT-5.4 and 7,000 on GPT-5.4-mini. It exists because heavy agentic use genuinely consumes that much: at API rates, an all-day agent workflow burns $300–$500 of tokens a month, so $200 flat is the cheaper way to buy that capacity.

The two Pro tiers are the same product at different scales, and the math for choosing between them is short:

Notice the asymmetry the diagram exposes: Plus → Pro 5x is linear (5x window, 5x price), but Pro 5x → Pro 20x gives you 4x the window for only 2x the price. If you are already paying $100 and still throttling weekly, the marginal $100 is the best-priced capacity OpenAI sells to individuals. The buying signal is simple: count throttle events. Zero per month means stay put; one or two during crunch means downshift models before upgrading; weekly means move up a tier and stop paying in waiting time.

Who actually needs Pro 20x: developers running multiple concurrent agent sessions, anyone using fast mode as a default (its 2.5x multiplier eats windows fast), and teams-of-one whose Codex output is their whole production pipeline. Who does not: anyone who has never hit the Pro 5x ceiling — the state of vibe coding data keeps showing most solo builders overestimate their tier by one.

Codex Business Plan & Enterprise Pricing: Seats vs Pay-As-You-Go

Codex Business costs $20 per user/month on annual billing ($25 month-to-month, 2-seat minimum) as of July 2026, and it is the first tier built around pooled, workspace-level usage instead of individual 5-hour windows. Each seat carries a Plus-sized Codex window, and admins can buy workspace credit top-ups centrally when the team runs hot.

One important change landed on June 24, 2026: usage-based Codex-only seats — the pay-as-you-go seats with no flat fee — are no longer available to new ChatGPT Business workspaces, or to workspaces that had never added one before that date. Workspaces that had a Codex seat (including pending invites) before June 24 are grandfathered and can keep managing and adding them. If your workspace qualifies, those seats remain the cheapest on-ramp for uneven usage: a contractor who runs $30 of tokens costs $30, not a $25 seat plus usage. If it does not, your options are standard Business seats plus top-ups, or the API for programmatic workloads.

Three things separate Business from stacking individual Plus accounts:

• Pooled credits and top-ups. Admins buy workspace credit top-ups centrally, so one developer's heavy week draws from the shared pool instead of hitting a personal wall.
• Grandfathered usage seats. Workspaces that added a Codex seat before June 24, 2026 can mix standard seats with pure pay-as-you-go Codex seats — the most flexible cost structure OpenAI has offered teams.
• Centralized billing and admin controls. One invoice, per-workspace management, SAML SSO, and Codex Sites access (publishing requires Business or Enterprise — see Codex Sites explained).

The billing objects and how they relate:

Budgeting guidance: plan for roughly $100–200 per developer per month all-in for engineers using Codex as a daily driver. The $20–25 seat is the floor, not the estimate; the real spend is seats plus the usage that flows through them.

A worked example for a five-person team: two heavy users at ~$150 of usage each, three occasional users at ~$30 each, plus five annual seats at $20. That is roughly $490/month, about $98 per developer, right at the bottom of the $100–200 guidance. The same team on individual Pro 5x plans would pay $500 in subscriptions alone, with nobody able to share a credit, which is the case for Business in one sentence.

New teams evaluating Codex after June 24 should walk this decision path:

How Much Does Codex Enterprise Actually Cost?

OpenAI does not publish Codex Enterprise pricing — it is quote-only, annual-prepay, and negotiated per contract. What procurement data exists in 2026 converges on roughly $45–$75 per seat per month, with reported seat minimums around 150, which puts the practical entry floor near $108,000 per year. Treat those numbers as procurement folklore with a real signal in it, not a rate card: the often-quoted "$60 average" traces back to a single old community post, and OpenAI has never confirmed a list price.

What is verifiable is the structure. Enterprise meters Codex against a shared, contract-level credit pool rather than per-seat caps — the credit rate card was applied to existing Enterprise plans on April 23, 2026 — and that pooling is the whole economic argument. On Business, one developer's monster week hits their seat's window; on Enterprise, it draws from a pool sized for the org, so bursty teams waste less purchased capacity.

A worked enterprise budget, using the midpoint estimate: 150 seats × $60 × 12 ≈ $108K/year in seats, plus a Codex credit pool. If a third of those seats are engineers averaging $120/month of Codex consumption, that is 50 × $120 × 12 = $72K/year of usage, for a realistic first-year total near $180K — roughly $100/month per active developer, which lines up neatly with the $100–200 guidance that keeps appearing at every scale.

Negotiation levers that show up in 2026 procurement write-ups: bring a competing quote (rival coding tools price $10–$15 per seat cheaper at the team tier), cap the renewal uplift in writing (2–3% annually is the reported norm), ask for pilot seats before the full minimum, and get the credit pool's overage rate in the contract rather than discovering it at renewal. None of this is exotic — it is the same playbook as any usage-priced SaaS, applied to a vendor whose list price does not exist.

Two adjacent notes for completeness. Edu follows the Enterprise model — contact-sales, negotiated per institution, with the same credit-pool structure; no public rate exists, so treat any specific Edu number you see online as unverified. And Codex Sites — publishing web apps straight from Codex — remains gated to Business and Enterprise workspaces, which matters for budgeting because it means the cheapest official path to a published Codex app is a 2-seat Business workspace at $40/month, before any usage. If publishing is the actual goal, compare that against builders where publishing is the default before you anchor on seat math; the Codex Sites breakdown walks through the gap.

Codex API vs Subscription: Which Is Cheaper?

Per token, they cost exactly the same. Since the April 2, 2026 restructure, every credit rate in the table above multiplies out to the API price at $0.04 per credit: GPT-5.5's 125 credits per million input tokens × $0.04 = $5, which is precisely the API rate. For reference, the API prices as of July 2026 (per 1M tokens):

So the question is not rate, it is packaging. The subscription wins for light and moderate use because a real allotment of credits is bundled into the flat fee: a Plus user consuming $40 of tokens inside their included window pays $20. The API wins for programmatic and bursty use: no 5-hour window, no per-seat fee, direct integration into CI or internal tools, and you pay only for what runs. Grandfathered Business workspaces can still split the difference with usage-based Codex seats; everyone else chooses per workload.

The break-even math is simple: a typical session costs $0.50–$2.00 in tokens, so 10–40 sessions a month is $20–$80 of consumption. Anyone coding most weekdays clears the value of a $20 Plus subscription easily; the plan effectively sells tokens below API cost in exchange for accepting the window. A reasonable rule: if you are a human in an editor, subscribe; if a script is doing the calling, use the API.

The rising line is API-priced consumption by sessions per month (at ~$1.25 average); the flat line is the $20 Plus fee. They cross around 16 sessions — roughly four sessions a week. Below that, the API's pay-per-use is genuinely cheaper and window-free; above it, the subscription is buying tokens at a discount. The same crossover logic applies one tier up: Pro 5x pays for itself near $100 of monthly consumption, Pro 20x near $200.

The setup most experienced teams land on is not either/or — it is both, split by workload. Developers get subscriptions, because humans in editors benefit from the bundled discount and tolerate windows. Machines get API keys, because CI pipelines, nightly batch jobs, and internal tools need predictable latency and cannot sit out a throttle. The failure mode to avoid is the reverse: running automated jobs through someone's Pro subscription (they will eat the shared window at 3 a.m.) or making a daily-driver developer pay list-price API rates for interactive work. Budget the two lanes separately and each one stays legible.

What's the Cheapest Way to Run Codex?

The cheapest legitimate Codex setup is Go at $8/month with disciplined model routing — and for many people the honest answer is even cheaper: the free tier plus the API for occasional bursts. Searches for cheap Codex access spike every month, so here is the full cost-minimization playbook, in the order that saves the most money first:

What Does Codex Fast Mode Cost?

Fast mode bills a multiplier on the standard credit rate — roughly 2.5x for GPT-5.5 and 2x for GPT-5.4 per the July 2026 rate card — in exchange for priority processing. The $2.40 refactor becomes about $6; the $0.40 bug fix becomes a dollar. That is worth it exactly when a human is waiting on the answer mid-flow, and worth skipping for anything running in the background. If fast mode has quietly become your default, it is usually the single biggest line item in a surprising bill: a Pro 5x user who runs everything fast is consuming like a Pro 20x user with none of the extra window.

Should You Buy a Discounted Codex Account?

No — and the search results offering "cheap Codex accounts" are the expensive option in disguise. Shared or resold ChatGPT accounts violate OpenAI's terms, get banned without refund, and hand a stranger access to your prompts, code, and connected repositories. The legitimate budget path covers the same ground: Free to evaluate, Go at $8 for light use, model routing to stretch any tier, and the API's pure pay-per-use when a subscription does not fit. Every dollar those gray-market listings save is borrowed against your account, your codebase, or both.

Codex vs Claude Code vs Cursor vs Copilot: Pricing Compared

All four major AI coding tools anchor near $20/month for individuals as of July 2026, and three of the four (Codex, Claude Code, Cursor) sell a $200 top tier for heavy users. The bigger story is convergence in the metering itself: within one quarter, the whole category moved to token-based usage — Codex on April 2, GitHub Copilot on June 1 (AI Credits replaced flat premium requests), and Cursor already passes model API rates through its included-usage pools. Claude Code is the holdout, metering session windows instead of itemized credits.

A few observations from the full head-to-head comparisons:

• Token metering won. A year ago these four tools had four different usage units; by July 2026, three bill by tokens and the fourth caps sessions. Cross-tool cost math is finally possible — and it converges on the same $100–200/month reality for heavy users everywhere.
• Copilot is the cheapest entry, at $10 with a usable free tier and unlimited code completions, but agentic work now draws token-priced AI Credits, so heavy agent use escalates toward Pro+ ($39) or Max ($100) just like everywhere else.
• Cursor's team pricing split in July 2026: Standard seats at $40/user monthly ($32 annual) and Premium seats at $120 ($96 annual) with 5x the usage — the same seat-tiering move Claude made, where Claude Code requires $100 Premium seats on Team plans (5-seat minimum). See Codex vs Cursor for the line-by-line.
• Claude Code and Codex mirror each other at $20 / $100 / $200, with Claude metering by session windows rather than itemized credits — the practical difference is that Codex tells you what each task cost and Claude tells you when you are done for the day. Background in the Claude Code history and Anthropic's full story.

Credit where each rival genuinely earns it: Copilot's unlimited code completions at $10 remain the best per-dollar autocomplete in the industry, and its GitHub-native review flow is unmatched if your team already lives in pull requests. Cursor's included-usage model is the most transparent of the four — you see dollar-denominated usage in real time, which makes it the easiest tool to reason about mid-month. Claude Code's session-cap model trades granularity for simplicity: no arithmetic, no rate card, just "you have hit today's limit," which some developers honestly prefer to watching a meter. These are real strengths, and the right choice depends on which trade-off matches how you work — the Cursor alternatives guide maps the whole territory.

What a heavy month costs on each, using each vendor's own tiering: Codex $100–$200 (Pro tiers), Claude Code $100–$200 (Max tiers), Cursor $200 (Ultra) or usage overages on Pro+, Copilot $100 (Max) plus credit overages. Every one of these is a coding tool: the output is code you still have to run, host, and maintain. For the adjacent question — which tool builds and hosts the whole app — see the best Codex alternatives breakdown and the wider AI app builder rankings.

Which Codex Plan Should You Pick?

Match the plan to how often you hit the window, not to how much you code. Start low; upgrading is instant, and the tiers are spaced so each one costs less than the equivalent API overage would.

One budgeting note that catches people: the jump from Plus to Pro 5x is 5x the price for roughly 5x the window, so the tiers are linear — but Pro 5x to Pro 20x is 4x the window for 2x the price, the only bulk discount in the ladder. The full decision matrix in one table:

How Do You Forecast a Codex Budget for the Rest of 2026?

Forecast consumption, not seats: (active developers) × (sessions per week each) × (average session cost) × 4.3, then add plan fees on top. That one line, fed with the task-table numbers from earlier, predicts a Codex bill within about 20% — which is as precise as any usage-priced tool allows and far better than the "wait for the invoice" approach most teams are running.

The variance drivers, ranked by how hard they can swing a month:

1. Agent adoption. The jump from "Codex answers questions" to "Codex runs multi-step tasks" multiplies consumption 3–10x per developer. If your team plans to adopt agentic workflows in Q3, budget the step change now, not after it lands.
2. Fast mode discipline. A 2–2.5x multiplier applied by default is the most common source of quiet budget doubling. Make it an explicit choice, not a setting someone forgot.
3. Model routing culture. Teams that route mechanical work to GPT-5.4-mini spend a fraction of teams that default everything to GPT-5.5. This is a habits problem, not a tooling problem — one pinned guideline in the team channel captures most of the saving.
4. Context hygiene. Cold-started sessions pay 10x on re-read context. Long-lived, well-scoped sessions are the cheap ones.
5. Release cadence. Crunch weeks spike 2–3x over quiet weeks; a monthly average hides that, a weekly tracking ritual does not.

A workable governance loop for a team lead takes fifteen minutes a week: pull the usage dashboard, flag any developer whose week doubled, ask which driver above caused it, and adjust the routing guideline or the plan tier — in that order. Upgrade tiers on sustained friction (throttle events every week for a month), never on a single spike. And re-run the whole forecast at each quarter boundary: OpenAI shipped four pricing changes in H1 2026 alone, and there is no reason to expect H2 to be quieter.

The uncomfortable honest note: a token-metered budget is never fully yours to control, because the meter prices effort, and effort depends on how the model behaves that week. If a forecast you can actually promise your finance team matters more than per-task granularity, that is not a Codex tuning problem — it is the structural argument for flat-priced tools, which is where the next section picks up.

The Flat-Pricing Alternative: Know Your Bill Before You Build

Taskade Genesis prices on a flat monthly plan, Free, then Pro $10/month billed annually ($20 month-to-month), with no token meter and no 5-hour window. You describe a dashboard, CRM, or client portal in plain language and get a live app with AI agents, automations, and 100+ bidirectional integrations. This predictability is why flat pricing matters most to the fastest-growing group of builders: non-technical operators who want a known number on the invoice.

The structural difference is what the meter is attached to. Codex meters effort — every token of reading, thinking, and writing bills against your window. Genesis prices the outcome: the app exists, runs, and stays published, and your plan price is the whole story. Taskade runs the workspace underneath — projects with all views, AI agents with persistent memory, and automations that keep working after the build — powered by 15+ frontier models from OpenAI, Anthropic, Google, and open-weight providers, with model routing handled for you. See how the pieces fit in the AI apps overview or the Genesis getting-started guide.

Think of who actually runs a business on this: a service-business owner who replaced four spreadsheets with one app, a clinic running a gated client portal, a realtor running an inbound CRM, each on a predictable flat plan, and on Business and up, each on their own custom domain with clients logging in. Browse real examples in the Community Gallery — the Meeting Cost Calculator is a fitting one for this article — and see the full plan matrix on the pricing page. If prompt-first building is new to you, the vibe coding primer covers the workflow in ten minutes.

Frequently Asked Questions

Related Reading

Codex, top to bottom:

• What Is OpenAI Codex? Complete History
• OpenAI Codex Sites Explained
• Best OpenAI Codex Alternatives (coders + non-coders)
• The OpenAI and ChatGPT Story

Head-to-head comparisons:

• Taskade Genesis vs OpenAI Codex
• Codex vs Claude Code
• Codex vs Cursor
• Codex vs GitHub Copilot

The wider AI coding market:

• Best Claude Code Alternatives
• Best Cursor Alternatives
• GitHub Copilot Alternatives
• AI Agents vs Copilots
• What Are AI Agents?

Codex pricing now rewards people who understand it: the credit system is transparent down to the token, but it still takes a rate card and a calculator to predict a monthly bill, and heavy users should budget $100–200/month. The arithmetic in this guide is that calculator — count your sessions, weigh your tasks, and the invoice stops being a surprise. If you'd rather know your cost up front and get the whole app, not just code, start free with Taskade Genesis →.

Before you go:

• Taskade Genesis overview — build your first app from one prompt
• How AI model credits work in Taskade — the flat-plan answer to this article
• Custom AI agents — the teammates inside your apps
• Automations execution — what keeps running after the build

Create a free account and see what a known bill feels like.

▲ Memory · ■ Intelligence · ● Execution — describe the app once, and your workspace remembers, thinks, and ships it.