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. This is the full breakdown: every plan from Go at $8 to Pro at $200, the exact credit rate card, what real tasks cost in dollars, how Business seats and top-ups work, and the flat-priced alternative for anyone who wants to know their bill before they build.
TL;DR: OpenAI Codex is bundled into ChatGPT plans: Free $0, Go $8, Plus $20, Pro $100/$200, Business $20/user/mo (annual). 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 team budgets land near $100–200/dev/month. Taskade Genesis is the flat alternative: Free, then $6/$10/$25. Start free →
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) 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.
| Plan | Price (July 2026) | Who it fits | Codex usage |
|---|---|---|---|
| Free | $0 | Trying Codex | Limited metered credits |
| Go | $8/mo | Light, occasional coding | Bigger allotment than Free |
| Plus | $20/mo | Solo daily driver | 15–80 GPT-5.5 messages per 5-hour window |
| Pro (5x) | $100/mo | Heavy solo use | 75–400 messages per window |
| Pro (20x) | $200/mo | All-day agent runs | 300–1,600 messages per window |
| Business | $20/user/mo annual ($25 monthly) | Teams | Pooled workspace credits, top-ups, Codex-only usage seats |
| Enterprise / Edu | Contact sales | Large orgs | Custom credit pools + Codex Sites |
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 seats.
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.
| Before April 2, 2026 | After | |
|---|---|---|
| Metering unit | Messages per window | Token credits (~$0.04 each) |
| One-line fix | 1 message | ~2–10 credits |
| Long multi-file refactor | 1 message | 60+ credits |
| Model choice | Same cost per message | Cheaper models draw fewer credits |
| Alignment with API | None | 1:1 with API token prices |
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.
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):
| Model | Input | Cached input | Output |
|---|---|---|---|
| GPT-5.5 | 125 | 12.5 | 750 |
| GPT-5.4 | 62.5 | 6.25 | 375 |
| GPT-5.4-mini | 18.75 | 1.875 | 113 |
| GPT-5.3-Codex | 43.75 | – | 350 |
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.
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.
Here is what that means in dollars for real work:
| Task | Credits | Approx. cost |
|---|---|---|
| One GPT-5.5 message | 5–45 | $0.20–$1.80 |
| Small bug fix | ~10 | ~$0.40 |
| Multi-file refactor | ~60 | ~$2.40 |
| Typical working session | varies | $0.50–$2.00 |
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 │
└───────────────────────────────────────────────────┘
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:
| Plan | GPT-5.5 messages per 5-hour window |
|---|---|
| Plus ($20) | 15–80 |
| Pro 5x ($100) | 75–400 |
| Pro 20x ($200) | 300–1,600 |
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.
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.
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. 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 that builds and publishes live apps, with no token metering.
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) as of July 2026, and it is the first tier built around pooled, workspace-level usage instead of individual 5-hour windows. It also introduces a second way to pay: Codex-only usage-based seats, with no flat per-seat fee, just metered credits for developers who need Codex but not the full ChatGPT workspace.
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.
- Codex-only usage seats. Pure pay-as-you-go: a contractor who runs $30 of tokens costs $30, not a $25 seat plus usage. This is the cheapest on-ramp for teams with uneven usage.
- Centralized billing and admin controls. One invoice, per-workspace management, and Codex Sites access (publishing requires Business or Enterprise).
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. Enterprise and Edu pricing is contact-sales, with custom credit pools, and is the only place a negotiated flat arrangement exists.
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.
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):
| Model | API input | API output |
|---|---|---|
| gpt-5.3-codex | $1.75 | $14 |
| gpt-5.4 | $2.50 | $15 |
| gpt-5.5 | $5 | $30 |
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. Business usage-based seats split the difference for teams.
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.
Codex vs Claude Code vs Cursor vs Copilot: Pricing Compared
All four major AI coding tools anchor near $20/month for individuals as of mid-2026, and three of the four (Codex, Claude Code, Cursor) sell a $200 top tier for heavy users. The real differences are in the metering unit: credits, session limits, included usage, or premium requests.
| Tool | Plans (mid-2026) | Usage model | What ~$20/mo buys |
|---|---|---|---|
| OpenAI Codex | Free / Go $8 / Plus $20 / Pro $100–$200 / Business from $20/user | API-aligned credits, rolling 5-hour window | Plus: 15–80 GPT-5.5 messages per window |
| Claude Code | Pro $20 / Max $100–$200 / Team from $25/user | Session limits (5-hour windows plus weekly caps) | Pro: Claude Code in terminal and IDE at entry-level limits |
| Cursor | Free / Pro $20 / Ultra $200 / Teams from $40/user | Included monthly usage at model API rates, then pay-as-you-go | Pro: a month of included frontier-model usage in the IDE |
| GitHub Copilot | Free / Pro $10 / Pro+ $39 / Business from $19/user | Premium-request allotment, extra requests ~$0.04 each | Two Pro seats, or Pro plus extra premium requests |
A few observations from the full head-to-head comparisons:
- The $0.04 unit is converging. A Codex credit and a Copilot premium request both price at roughly $0.04, which makes cross-tool math easier than it used to be.
- Copilot is the cheapest entry, at $10 with a usable free tier, but its allotment model means heavy agentic use escalates to Pro+ or overage billing quickly.
- Cursor and Codex have functionally merged pricing philosophies: both now pass through model API rates, with a flat fee buying an included allotment (see Codex vs Cursor).
- Claude Code and Codex mirror each other at $20 / $100 / $200, with Claude metering by session windows rather than itemized credits.
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 Claude Code vs Cursor vs Taskade comparison.
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. There is no bulk discount for going up, only relief from the ceiling.
The Flat-Pricing Alternative: Know Your Bill Before You Build
Taskade Genesis prices on a flat monthly plan, Free, then Starter $6, Pro $10, Business $25, 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+ 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.
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, and see the full plan matrix on the pricing page.
Frequently Asked Questions
How much does OpenAI Codex cost?
Free $0, Go $8/mo, Plus $20/mo, Pro $100/$200, Business $20/user/mo annual ($25 monthly), Enterprise contact-sales, all metered by token credits on a rolling 5-hour window since April 2, 2026.
How much is one Codex credit?
About $0.04, aligned 1:1 with API token prices. A GPT-5.5 message runs 5–45 credits ($0.20–$1.80); a small bug fix is 10 credits ($0.40); a multi-file refactor is 60 credits ($2.40).
Is Codex free?
It is bundled into ChatGPT's free tier with limited metered usage, and Go at $8/mo is the cheapest paid step. There is no flat unlimited plan below Enterprise. Taskade Genesis has a usable free plan that builds and publishes live apps.
What happens when I hit the 5-hour limit?
Codex pauses until the rolling window refills. You can wait, switch to a cheaper model (GPT-5.4 draws half of GPT-5.5's credits), upgrade a tier, or buy a Business workspace top-up.
Codex API vs subscription: which is cheaper?
Identical per token since April 2026. Subscriptions win for humans in editors because credits are bundled into the flat fee; the API wins for scripts and CI because there is no window and no seat fee.
How do I make Codex credits last longer?
Use cached context (cached input is 10x cheaper than fresh input), pick the lightest model that handles the task (GPT-5.4-mini draws about a seventh of GPT-5.5's credits), and scope tasks tightly, since output tokens cost roughly six times input.
How does Codex pricing compare to Claude Code, Cursor, and Copilot?
All anchor near $20/mo for individuals: Codex Plus $20, Claude Pro $20, Cursor Pro $20, Copilot Pro $10, with $200 top tiers on Codex, Claude, and Cursor. See the Codex vs GitHub Copilot breakdown for the closest matchup.
What's the cheapest prompt-to-app builder?
Taskade Genesis (free, then $10/mo Pro) builds and hosts the whole app with no metering, cheaper and more predictable than Codex Sites (Business/Enterprise only), Lovable Pro ($25), or Replit Core ($25 + deploy fees).
Related Reading
- What Is OpenAI Codex? Complete History
- OpenAI Codex Sites Explained
- Best OpenAI Codex Alternatives (coders + non-coders)
- Taskade Genesis vs OpenAI Codex
- Claude Code vs Cursor vs Taskade Genesis
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. If you'd rather know your cost up front and get the whole app, not just code, start free with Taskade Genesis →.
▲ Memory · ■ Intelligence · ● Execution