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

OpenAI Codex has no standalone price. As of September 29, 2026 it is included in ChatGPT plans that cost $0 to $500 per month, or you pay API token prices with an API key, and since April 2, 2026 usage is metered with token-based credits worth about $0.04 each. On DevDay 2026, OpenAI added a $500 Pro 500 plan, cut the usage allowance on new Pro 200 subscriptions, and shipped GPT-6.1 Sol at $2 per million input tokens. That is why "codex pricing" keeps spiking in search: your bill depends on which plan, which model, 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 500 at $500, the Codex credit rate for each GPT-6 model, the September 2026 GPT-6 API prices, a worked 50-step agent session, an ASCII cost worksheet, subscription-versus-API break-evens, what light, moderate, and heavy months really cost, how Business and Enterprise billing works after the June 24 seat change, and what you can build in Taskade Genesis when a flat-priced plan fits the job better.

OpenAI Codex pricing is a token-metered credit system layered on ChatGPT subscriptions: every tier from Free to Pro 500 ($500/month) buys a differently sized usage allowance, and credits worth about $0.04 each cover the overflow, so your real monthly cost depends on tokens burned, not tasks completed.

TL;DR: Codex is bundled into ChatGPT plans: Free, Go $8, Plus $20, Pro $100, Pro $200, and the new Pro 500 at $500 with Ultrafast. The GPT-6.1 Sol API costs $2 input and $10 output per 1M tokens, about $1.37 per 50-step agent session. Flat alternative: Taskade Genesis, free, then $10/mo billed annually. Start free →

Last updated: September 29, 2026: added the DevDay 2026 pricing changes (Pro 500, the new Pro 200 allowance, GPT-6.1 Sol, Ultrafast), the credit rate for each GPT-6 model and OpenAI's included-usage estimates (both from OpenAI's pricing page and rate card, read September 29), GPT-6 API price tables, a worked 50-step session, subscription-versus-API break-evens and a pricing history. GPT-5.5-era credit rates, window limits and competitor prices further down are labeled July 2026. OpenAI retires GPT-5.5 from Codex on October 14, 2026, so treat those tables as legacy.

Start on the Free plan: Taskade Genesis includes 3 apps, 1 AI agent, and 2 workspace members at $0. Pro starts at $10 per month billed annually. Build your first app →

How Much Is Codex? Codex Pricing at a Glance (Updated September 29, 2026)

Codex costs $0 to $500 per month for individuals as of September 29, 2026, because it is bundled into ChatGPT plans: Free, Go at $8, Plus at $20, and Pro at $100, $200, or the new $500 Pro 500 tier that adds Ultrafast. An API key skips the plan and bills per token. Business Standard seats cost $20 per user per month billed annually. Through the API, GPT-6.1 Sol costs $2 per million input tokens and $10 per million output tokens.

OpenAI now names the personal Pro plans by price (Pro 100, Pro 200, Pro 500). Older guides, and the July 2026 sections of this one, call them Pro 5x and Pro 20x after their allowance multiples. Same plans, new labels.

*The 5x and 10x multiples come from OpenAI's Codex lead on X, as reported by BGR. OpenAI's help center states that Pro 200 includes more usage than Pro 100 and that Pro 500 offers the highest included usage, and its DevDay recap lists 25x Plus for Pro 500. Pro is billed monthly only.

The API side of the same coin, in dollars per 1M tokens. OpenAI's pricing page lists these as standard rates for the newest models:

Speed tiers multiply those rates. Here is the whole ladder for the two models where OpenAI published every tier:

Ultrafast has two sixes and two eights that people mix up. OpenAI's documents say Ultrafast delivers up to 8x faster token generation in Codex and up to 6x faster in the API, at about 300 tokens per second. That is a speed claim. The price is a separate number: Astra Ultrafast bills at 6x the standard API rate ($60 and $300 versus $10 and $50). A third pair sits on OpenAI's pricing page: Astra Ultrafast uses 8x your included subscription usage and 6x purchased credits. Those are billing multipliers, and OpenAI states they do not describe speed. A forum post that says "6x" or "8x" without saying speed or price, and Codex or API, is mixing them up. Sol Ultrafast was announced with "up to 8x faster token generation" in Codex and no price yet.

What Are Codex Credits Per Million Tokens for GPT-6?

On OpenAI's rate card, GPT-6.1 Sol draws 50 credits per million input tokens, 2.5 credits per million cached input tokens and 250 credits per million output tokens. At about $0.04 per credit, that is $2, $0.10 and $10, so the credit meter and the API price list agree for every GPT-6 row. This is the "codex credits" table that most guides still print for GPT-5.5.

Three things follow from the table. Output costs 5x input on every GPT-6 row. Codex credit billing has no separate cache-write charge, so the cache-write column in the API table does not apply to credits. And Luna costs one-twentieth of Sol per token, which makes it the cheap lane for mechanical work now that GPT-5.4-mini is gone from ChatGPT-signed-in Codex.

The other half of the picture is how much your plan includes before credits start. OpenAI's pricing page gives these local-message estimates per five-hour period for Plus and Standard Business. It says they are estimates, not fixed limits, that cloud tasks use more, that weekly limits may also apply, and that Pro plans currently have no five-hour limit.

Speed modes change how fast the allowance drains:

Retirement notice: OpenAI's pricing page says GPT-5.5 retires from ChatGPT, ChatGPT Work and Codex on all plans on October 14, 2026, and its rate card says GPT-5.4 and GPT-5.4 mini are already unavailable in Codex when you sign in with ChatGPT (use GPT-5.6 Terra and GPT-5.6 Luna). The API and Codex with your own API key are not affected. The GPT-5.5, GPT-5.4 and GPT-5.4-mini figures later in this guide are July 2026 legacy numbers. They still teach the method, and the lever of routing routine work to a small model carries over to GPT-6 Luna.

Sources, all checked on September 29, 2026: OpenAI's Codex pricing page, the Codex rate card, OpenAI's About ChatGPT Pro tiers help article, the API pricing page, Introducing GPT-6.1 Sol, Premium seats on ChatGPT Business, and the DevDay 2026 developer thread. Vendor benchmark and speed claims are OpenAI's own.

What Changed on September 29, 2026: Pro 500, the New Pro 200, and GPT-6.1 Sol

OpenAI changed three things about Codex pricing on September 29, 2026: it launched the $500 Pro 500 plan, it lowered the included allowance on new Pro 200 subscriptions while keeping the $200 price, and it released GPT-6.1 Sol into ChatGPT Work and Codex at one-fifth of GPT-6 Astra's API price. Eligible existing Pro 200 subscribers keep their old allowance through October 29.

Three details matter for anyone budgeting:

• Keeping the old allowance does not upgrade you. OpenAI's help center says an existing Pro 200 subscriber who keeps the previous allowance still has Pro 200: no Pro 500 features and no Ultrafast. After October 29, 2026, the subscription moves to the lower allowance at the same $200.
• Credits do not buy Ultrafast on the lower plans. At launch, buying credits on Pro 100 or Pro 200 does not unlock Ultrafast. On Pro 500, Ultrafast draws from included usage first and then from your credit balance.
• The price per unit of usage is now flat across the ladder. If Pro 100 is 5x, new Pro 200 is 10x, and Pro 500 is 25x Plus, every tier costs exactly $20 per Plus-sized unit of usage. The old 20x Pro 200 was the one bulk discount ($10 per unit), and it survives only for grandfathered subscribers until October 29.

Arithmetic: $20 / 1x, $100 / 5x, $200 / 20x, $200 / 10x, $500 / 25x. The 5x and 10x multiples are reported by BGR from OpenAI's Codex lead, so treat those two bars as reported figures.

GPT-6.1 Sol in Codex. OpenAI released GPT-6.1 Sol on September 29 to Plus, Pro, Business, Enterprise, and Edu users in ChatGPT Work and Codex, with the rollout starting on Pro. It is not yet available in regular Chat. GPT-6 Astra usage in Work and Codex draws from your plan allowance at standard or Fast speed: Pro 100, Pro 200, and Business Premium seats can use their full existing allowance for Astra, while Plus and Business Standard seats include limited Astra usage with optional credits after that. Sol replaced GPT-6 Sol after seven days, and Artificial Analysis measured it one point below Astra on its Intelligence Index at $0.72 per task versus $3.26 for Astra at max effort. For what the GPT-6 tiers are and why they exist, see What Is GPT?.

Cost per unit of useful work is falling faster than plan prices. That is the theme of the AI cost per task analysis, and the worked example below turns it into dollars.

Is There a Flat-Price Alternative to Codex Credits?

Yes, for a different job. Taskade Genesis turns one prompt into a live, hosted app with its own data, AI agents and automations, and it prices by plan: Free costs $0 with no credit card and starts with no AI credits (earn credits or buy a credit pack), then Pro is $10/month billed annually with 50,000 credits every month. There is no rolling five-hour window. If you run out, buy more credits or turn on auto top-up. The example-apps table later in this guide shows what that buys, and the Codex vs. flat-price builder comparison gives the line-by-line view.

• Free plan: 3 Taskade Genesis apps, 1 AI agent, 2 workspace members, 10 automation runs a month, no credit card.
• Pro: $10/month billed annually ($20 month-to-month), 50,000 credits/month, up to 10 custom domains.
• Business: $25/month billed annually, for teams that need SSO or more than 10 seats.
• Taskade Genesis apps publish live at a shareable URL by default, on every plan, Free included.

Start building free on Taskade Genesis →

How Much Does OpenAI Codex Cost?

As of September 29, 2026, OpenAI Codex costs $0 to $500 per month for individuals: Free, Go at $8/month, Plus at $20/month, and Pro at $100/month (5x capacity), $200/month (20x through October 29 for existing subscribers, lower for new ones), or $500/month (Pro 500, 25x). Teams pay $20 per user/month on annual billing ($25 month-to-month, 2-seat minimum) for Business, and Enterprise/Edu is contact-sales. The table below keeps the July 2026 window sizes, and every tier meters Codex with token-based credits, so the plan you buy determines how big your allowance is, not a fixed number of tasks.

One update to the Pro rows: OpenAI's pricing page now says Pro plans currently have no five-hour limit. The Pro window ranges in this table are the July 2026 GPT-5.5 figures, and the Sept 29 estimates for GPT-6 are in the tables at the top.

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. Pro 500 at $500 is for people whose agents run in parallel all day and who will pay for latency. Here is the identity card for the whole system:

One structural takeaway before the details: Codex plans fall into three lanes. 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 mattered. The first half of 2026 rewired Codex billing in several steps, and two of them change what teams should buy today: Pro 5x launched on April 9 to fill the gap between Plus and Pro 20x, and usage-based Codex-only seats closed to new Business workspaces on June 24. 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. The history table below lists every dated change, and the fuller product backstory is in the complete OpenAI Codex history and the broader OpenAI and ChatGPT story.

Codex and Model Pricing History, 2025 to September 29, 2026

OpenAI changed Codex plans or model prices at least 12 times between the 2025 launch and September 29, 2026, and the API price of its workhorse model fell 60% (input) to 67% (output) in five months. The table lists every price or plan change we could verify, newest last. Dates and prices come from OpenAI's announcements, API changelog, and help center.

The five points are GPT-5.5 (Apr 23), GPT-5.6 Sol (Jul 9), GPT-5.6 Sol after its promo cut (Aug 21), GPT-6 Sol (Sep 22), and GPT-6.1 Sol (Sep 29): the model most Codex users default to at each date. Input price fell 60% ($5 to $2) and output price fell 67% ($30 to $10). Cached input fell from $0.50 to $0.10, an 80% cut.

The pattern to plan around: per-token prices fall in steps every few weeks, while plan prices move rarely and mostly upward at the top (Pro 500 is a new rung, and the Pro 200 allowance shrank). Meanwhile agent sessions burn more tokens each. The state of vibe coding data shows the same shift from seats to consumption across the category. The rule of thumb: re-price your Codex budget every time a new model tier ships, because the cheapest way to buy the same work changes faster than the plan ladder does.

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. The GPT-6 rates are in the table near the top of this guide. The table below is the GPT-5.5-era rate card as of July 2026 (credits per 1M tokens). GPT-5.5 retires from Codex on October 14, 2026, and GPT-5.4 and GPT-5.4 mini already left ChatGPT-signed-in Codex, so read it as a legacy reference that shows the method.

Two patterns to internalize. First, output tokens cost about six times input tokens on GPT-5.5 and GPT-5.4 (five times on the GPT-6 models), 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; GPT-5.5 examples, July 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.

GPT-5.4-mini is no longer offered in Codex when you sign in with ChatGPT. GPT-6 Luna is the small-model lane now: at 2.5 credits per million input tokens and 12.5 per million output tokens, it draws about one-fiftieth of GPT-5.5's input rate and one-sixtieth of its output rate.

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.

Worked Example: A 50-Step Agent Session on GPT-6.1 Sol vs GPT-6 Sol

A 50-step Codex agent session with a 60,000-token prefix and a 90% cache hit rate costs about $1.37 on GPT-6.1 Sol at API list prices, versus about $1.64 on GPT-6 Sol and $8.20 on GPT-6 Astra. The session bills 3 million input tokens in total, and 90% of them arrive at the cached rate, which is why the cache price matters more than the headline input price.

The assumptions, so you can swap in your own numbers:

• Each of the 50 steps re-sends a 60,000-token prefix (instructions, tool definitions, repository context), so total input is 50 × 60,000 = 3,000,000 tokens.
• The cache hit rate is 90%: 2,700,000 tokens bill at the cached rate, 300,000 tokens bill fresh.
• The agent writes 1,000 output tokens per step, so total output is 50,000 tokens.
• Prices are API list prices per 1M tokens from OpenAI's pricing page. Cache-write surcharges are ignored: writing the 60,000-token prefix once at $2.50 instead of $2 adds about $0.03. Codex credit billing has no separate cache-write charge, so that line applies only to the API.

In Codex credits the same GPT-6.1 Sol session is 0.3 × 50 + 2.7 × 2.5 + 0.05 × 250 = 15 + 6.75 + 12.5 = 34.25 credits, which is $1.37 at $0.04 per credit. Four things fall out of the arithmetic:

• Halving the cache price cut the session by about 16%. GPT-6.1 Sol and GPT-6 Sol have identical input and output prices. The whole difference is the cached rate, $0.10 versus $0.20, and cached tokens are 90% of the input.
• Caching is worth more than model choice. Without any cache, the same session on GPT-6.1 Sol costs 3 × $2 + $0.50 = $6.50, so the 90% hit rate saves 79%. Read how prompt caching works and keep tool definitions and instructions stable, because a changed prefix is a cache miss you pay for.
• More output tokens do not erase the saving. Artificial Analysis found GPT-6.1 Sol uses about 10 to 30% more output tokens than GPT-6 Sol. At the midpoint, 60,000 output tokens cost $0.60, the session lands at $1.47, and GPT-6 Sol is still $1.64.
• Speed tiers are the expensive knob. Fast mode doubles the session to $2.74 on GPT-6.1 Sol. Astra Ultrafast bills 6x standard: 0.3 × $60 + 2.7 × $6 + 0.05 × $300 = $18.00 + $16.20 + $15.00 = $49.20 for the same session.

Luna: 0.3 × $0.10 + 2.7 × $0.01 + 0.05 × $0.50 = $0.03 + $0.027 + $0.025 = $0.08. GPT-6 Luna suits the mechanical steps of an agent loop, the same routing idea as the GPT-5.4-mini advice later in this guide. These are our estimates from published prices, not OpenAI figures, and real sessions vary with reasoning effort and tool output size.

Subscription vs API: Where Is the Break-Even?

A subscription beats API list prices once you run more sessions per month than the plan price divided by the cost of one session. For the 50-step session above, that is $20 / $1.37 = about 15 sessions a month on Plus, and about 365 sessions on Pro 500. The table divides each plan price by the session cost of three models.

How to read it: a Plus subscriber who runs 30 such sessions on GPT-6.1 Sol consumes about $41 of API-priced tokens for $20. A Pro 500 subscriber needs 365 sessions, roughly 17 per workday, before $500 of API-priced tokens matches the plan price. That is why Pro 500 is a latency purchase for most people, not a token-discount purchase: the Ultrafast tier is the feature you cannot buy on the cheaper plans, even with credits.

Two caveats keep the table honest. First, OpenAI does not publish the plan allowances in dollars, so the plan may run out of allowance before you reach the break-even count, and the overflow bills as credits. Second, the subscription only wins if a human is in the loop. A nightly script or a CI job does not need a plan window, and it pays the same list price through the API. The rule from earlier in this guide still holds: if a human is in an editor, subscribe; if a script is calling, use the API. The inference cost and token wiki pages explain the units.

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. Business Premium seats are the exception: OpenAI says they remove the five-hour limit and reset weekly. The GPT-6 estimates are in the tables near the top of this guide (Plus and Standard Business: 15 to 160 GPT-6.1 Sol messages and 350 to 3,000 GPT-6 Luna messages per window), and OpenAI now says Pro plans have no five-hour limit. As of July 2026, the windows translated to these GPT-5.5 message ranges, which are legacy numbers:

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-6 Luna draws one-twentieth of GPT-6.1 Sol's credits), 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. In real use the Working state loops back into Burning with every new task, which the diagram leaves out so the forward path stays readable:

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 know the mechanic, schedule around it: put agent runs and big refactors at the start of the day when the window is fresh, and push questions and reviews into the hours after a heavy block. 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.