Free tool · no signup · nothing leaves this page

Which ChatGPT plan survives your Codex week?

Codex has no price of its own. You buy a ChatGPT plan and it comes with it, metered by two meters running at once: a rolling five-hour window and a weekly limit above it. Since April 2026 both are counted in credits, which turns out to be the one honest unit for comparing plans. Set your real usage below and this ranks Free, Go, Plus, Pro 5x, Pro 20x, a Business seat, flex credits, stacked accounts, hosted inference, and a raw API key by what they cost and whether they make it to Friday.

01 · The picker

How you actually work

Wall-clock time with an agent working, not time at the keyboard.

Two agents running for an hour is two agent-hours. This is the single biggest driver.

Model mix
Sol 20% Terra 60% Luna 20%

Terra takes whatever is left and is the 1.0 unit. Sol burns exactly 2.5x a Terra hour and Luna exactly 0.1x, because that is the ratio of their published token prices. Free and Go cannot select Sol at all.

Assumptions, and which numbers are derived

Everything reduces to one unit, and here the unit is OpenAI's own: the credit. Since April 2026 Codex meters tokens rather than messages, and credits are what tokens are counted in. Sol, Terra and Luna convert into a Terra-equivalent agent-hour at their published token-price ratios, which are exact rather than blended: Sol is $5 in and $30 out per million against Terra's $2 and $12, so a Sol hour counts as 2.5. Luna is $0.20 and $1.20, so a Luna hour counts as 0.1. The whole family is a clean 25 to 10 to 1.

  • Published. The plan ladder: Free $0, Go $8, Plus $20, Pro from $100 for 5x higher rate limits than Plus and $200 for 20x, Business $20 per user per month on annual billing or $25 monthly with a two-seat minimum, Enterprise and Edu on request. Read from OpenAI's Codex pricing documentation on 20 August 2026. Note that this supersedes the single $200 Pro rung described in older writing, including our own guide: the $100 Pro tier arrived in April 2026.
  • Published. The two meters. OpenAI's wording is that local messages and cloud chats share a rolling five-hour window, and that additional weekly limits may apply. Every Codex surface counts against the same allowance: the CLI, the IDE extension, the desktop app, Codex cloud and iOS. Only an API key sits outside both.
  • Published. Messages per five-hour window, which is the number this tool converts into capacity. On Plus: Sol 10 to 100, Terra 25 to 200, Luna 250 to 2,000. Pro 5x and Pro 20x are exactly five and twenty times each of those figures on every row, and a Business seat carries the same numbers as Plus. Free and Go publish no per-model row at all and the Codex model documentation lists Terra only on both, which is why a Sol share breaks them in the ranking above rather than merely costing more.
  • Published. The credit rate card, per million tokens: Sol 125 in and 750 out, Terra 50 and 300, Luna 5 and 30.
  • Published. API list rates per million tokens, short-context tier: Sol $5.00 in, $0.50 cached, $30.00 out; Terra $2.00, $0.20, $12.00; Luna $0.20, $0.02, $1.20. Long context is a separate column at 2x input and 1.5x output across the whole family. Read from OpenAI's API pricing on 20 August 2026.
  • Derived, and checked. A credit is $0.04. OpenAI publishes the rate card in credits and the price list in dollars but never states the exchange rate, so we solved for it: Sol's 125 credits per million input tokens against its $5.00 per million input tokens gives four cents, and the same four cents reproduces all six published figures across the three models to the cent. The practical consequence is worth stating plainly: Codex credits are sold at exact API parity, so buying overflow is never more expensive per token than an API key.
  • Derived, and checked three ways. The five-hour window capacity. OpenAI publishes message ranges rather than a budget, so we inverted them against its own note that GPT-5.6 usage averages 5 to 40 credits per message. On Terra both ends close exactly on the same figure: 25 expensive messages at 40 credits and 200 cheap ones at 5 credits are both 1,000 credits. That same 1,000-credit budget then reproduces Luna's published 250 to 2,000 range exactly at both ends, and Sol's low end of 10 exactly. Only Sol's published high end is about 25 percent more generous than the budget implies. So Plus and a Business seat carry 1,000 credits per window, Pro 5x carries 5,000, and Pro 20x carries 20,000, which is $40, $200 and $800 of inference respectively.
  • Derived, with no published basis at all. Free at 50 credits per window and Go at 125. OpenAI gives no per-model row for either and describes them only as quick and lightweight coding tasks, so these are our floor estimates at 5 and 12.5 percent of Plus. Treat both rows as directional. What is not a guess is the model gate: neither plan carries Sol.
  • Derived, and the weakest number on this page. The weekly limit. This is the one figure OpenAI genuinely does not publish: its wording is that additional weekly limits may apply, with no number attached. We set the weekly ceiling at three windows' worth of credits, so 3,000 on Plus, 15,000 on Pro 5x and 60,000 on Pro 20x. That is calibrated against the widely reported experience that an account running Codex most of the working day meets a weekly limit in the second or third day, and against the fact that a cap OpenAI thought worth warning about must bind somewhere well below the 33 windows a week contains. If you only take one number here with a pinch of salt, take this one.
  • Derived, and the reason the ranking is not sharper than its inputs. Because that weekly figure is an estimate, a plan has to fit inside 85 percent of it before this tool calls it a survivor. The margin applies to the weekly ceiling only, not to the five-hour window, which is derived but checked three ways against published numbers. Without it a profile landing four percent under an estimated cap would outrank a plan with real headroom, which is advice built entirely out of the weakest figure on the page. It is the same instinct behind our Claude tool using the low end of Anthropic's published ranges: a plan you pick on the optimistic end is a plan that fails in week two.
  • Derived. The heavy-context factor of 1.43. Unlike Anthropic, OpenAI publishes the surcharge itself: past the long-context threshold a request bills at 2x input and 1.5x output, and on the token shape below that makes a crossing request cost 1.86x. What it does not publish is how often an agent session crosses, so the toggle assumes about half of requests do. An agent that reads twelve files before editing one crosses far more easily than a chat does.
  • Derived. Token throughput of about 2.7 million tokens per agent-hour with a warm prompt cache, which is what turns hours into credits and prices the API row. It comes from a worked twenty-turn agent session (115k cache writes, 1.24M cache reads, 16k output) taken at two sessions an hour, and on Terra's rates it lands at $1.34, or 33.5 credits, per Terra-equivalent agent-hour.
  • Ours, and in the ranking on the same rule as everything else. Continuum's hosted plans carry a weekly dollar allowance consumed at the same API-equivalent burn as every other row, and fit only while the week's dollar figure stays under the allowance. Two guards keep it honest: a Continuum plan can never displace a cheaper OpenAI plan that also survives, and on an exact price tie the OpenAI plan wins. What the allowance buys is hosted inference on any model through an OpenAI- and Anthropic-compatible endpoint, so it is priced here at OpenAI list rates to keep the comparison like for like; Continuum's own per-model rates are on the pricing page and are not identical, so read the headroom figure as indicative.
  • Ranking rule. The metered portion of a row has to come in about 25 percent under a fixed monthly price before it is allowed to outrank it. Inside that band the known invoice wins, because the estimate's own variance is wider than the gap. Only the metered part carries the penalty: a $100 plan with $12 of credits on top is mostly a known invoice, and taxing all of it would price a certainty as a guess.
  • Judgement call. Meeting the five-hour window is treated as a degraded week, not a broken one, which is the opposite of how our Claude tool treats it and the difference is real. The window refills continuously, and Luna costs a tenth of Terra on every paid plan, so an overflowing window costs you an afternoon or one /model command. The weekly limit is the hard stop, because nothing you switch to clears it.
  • Simplification. Cap-fire days assume your week is spread evenly across the days you selected. A real Monday-heavy week fires earlier than the number shown.
  • Simplification. The credit rows price the larger of two shortfalls, weekly and window. Window overflow is charged per window rather than once a week, since it recurs every time the window refills.
  • Not modelled. Fast mode, which is a priority service tier that bills credits at a higher rate on the models that support it. Enterprise and Edu, which have no published rate limits and scale with workspace credits. Annual billing on personal plans. And a reported temporary suspension of the five-hour restriction on some paid plans in July 2026: OpenAI's own pricing documentation still describes the window as live today, so this tool models it as live.

Prices, limits and rate cards read from OpenAI on 20 August 2026. OpenAI has changed Codex pricing twice this year; check the numbers before you commit a year to one.

02 · The plan ladder

Codex plans: six rungs, and one of them is new.

Codex pricing looks like a ChatGPT subscription with a coding agent bolted on. It is actually a ladder with six rungs, and the rung most writing about it still misses is the $100 one.

What you are actually buying

The Codex price question has an awkward answer, which is that there is no Codex price. Every ChatGPT plan includes Codex on the web, in the CLI, in the IDE extension, in Codex cloud and on iOS, and they all draw on one allowance rather than five. What the plan sets is headroom, and headroom is metered by two ceilings that count at the same time.

The first is a rolling five-hour window, which local CLI messages and cloud chats share. It refills continuously as older activity ages past the five-hour mark, so meeting it costs you part of an afternoon. The second is a weekly limit above it, and this is where OpenAI stops publishing numbers: the documented wording is that additional weekly limits may apply. Meeting that one costs you days rather than hours, and no model switch clears it.

The reason the window is the softer ceiling is the model ladder underneath it. GPT-5.6 Luna costs a tenth of Terra per token and a twenty-fifth of Sol, on the credit rate card and on the API alike, so dropping a rung genuinely restores capacity in a way that switching models on a shared Anthropic weekly pool does not. That single fact is worth more than most of this page.

Rung one and two: Free and Go, and their real limit

Free includes Codex for what OpenAI calls quick coding tasks, and Go at $8 for lightweight ones. Neither publishes a per-model allowance. The constraint that actually decides them is not volume: neither plan carries GPT-5.6 Sol. If your work needs the flagship, these rungs are not small versions of Plus, they are a different product.

Rung three: Plus at $20, and why it is the honest answer more often than people expect

Plus is the real entry point and it already selects Sol, so paying more does not get you a better general model. OpenAI publishes Plus at 10 to 100 Sol messages, 25 to 200 Terra, or 250 to 2,000 Luna per five-hour window. Those ranges are wide for a real reason: a message is not a unit, tokens are, and one high-effort turn against a large repository can cost what twenty focused prompts against one file cost. The range is the difference between disciplined and careless use, and it is entirely under your control.

The comparison nobody makes is the one that matters. A developer using an agent most of a working day generates token volume that prices in the hundreds of dollars a month at list rates. If you already pay $20 for ChatGPT, you already own a terminal coding agent and may not have noticed.

The new rung: Pro at $100 for 5x, and Pro at $200 for 20x

This is the change most Codex writing has not caught up with. Pro is no longer one $200 plan. OpenAI now sells it as a choice of 5x or 20x higher rate limits than Plus, from $100 a month, with the $200 tier carrying the 20x multiplier. The published message ranges confirm the multipliers hold exactly: Pro 5x is 50 to 500 Sol messages per window against Plus's 10 to 100, and Pro 20x is 200 to 2,000. The same clean 5x and 20x holds on the Terra and Luna rows too.

That linearity is the single biggest structural difference from Anthropic's ladder, and it flips a common piece of advice. Anthropic's weekly floors compress at the top, which is why two stacked Max 5x accounts can beat one Max 20x for the same $200. OpenAI's do not compress, so two stacked Pro 5x accounts are strictly worse than one Pro 20x at the same price on weekly headroom, and buy you only a second independent window in exchange. The picker above will show you that directly rather than asking you to take it on faith.

The rung beside the ladder: Codex credits

Plus and Pro accounts that reach their limit can buy credits; Business, Edu and Enterprise workspaces buy workspace credits. Included usage is always spent first. The rate card is published per million tokens: 125 credits in and 750 out on Sol, 50 and 300 on Terra, 5 and 30 on Luna.

What OpenAI does not publish is the exchange rate, and it is worth solving for, because it settles the credits-versus-API question outright. Sol's 125 credits per million input tokens sits against a published API price of $5.00 per million input tokens, which puts a credit at four cents, and four cents reproduces all six published rate-card figures exactly. Credits are sold at exact API parity. So the choice between buying credits and adding an API key is not a price decision at all, it is a decision about whether you want one invoice or two.

And the two rungs that are not a ChatGPT plan

An API key has no window and no weekly limit. Nothing ever stops, which is the point and also the risk. It is the correct tool for CI, for scheduled jobs, and for anything running without a person present, because a subscription covers interactive use by one person rather than a build server. Set a spending limit in the console before the first unattended run rather than after the first surprise.

Hosted inference is the other shape: a weekly dollar allowance rather than a message window. Continuum's Plus, Max 100, Max 200 and Ultra plans give you $25, $100, $200 and $1,000 of inference a week on any model, through an OpenAI- and Anthropic-compatible endpoint, with no five-hour window and no per-model cap. Against a ChatGPT plan the trade is legible in both directions: a ceiling denominated in dollars you can read rather than a weekly limit you have to infer, but a subscription's marginal turn is free once bought while an allowance is spent as it goes. Those plans rank above on the same rule as everything else and are never allowed to displace a cheaper OpenAI plan that also survives your week.

Longer versions of all of this live in the Codex pricing guide and the Codex models guide.

03 · Side by side

Every price and every message range read from OpenAI on 20 August 2026 and checked August 2026. Message figures are OpenAI's own published per-window ranges, shown as the ranges they were published as.

Thirteen ways to pay for the same agent, and what each ceiling is denominated in. checked aug 2026
Plan Price / mo Sol msgs / 5h Terra msgs / 5h Luna msgs / 5h Weekly limit Best for
ChatGPT Free$0no Solnot publishednot publishedappliesFinding out what Codex is.
ChatGPT Go$8no Solnot publishednot publishedappliesOccasional lightweight edits.
ChatGPT Plus$2010 to 10025 to 200250 to 2,000appliesIndividual daily agent work.
Plus plus credits$20 plus overflowIncluded usage first, then metered at the rate card, which is API paritythen meteredSeasonal crunches, not constant load.
Business seat$25, or $20 annual10 to 10025 to 200250 to 2,000appliesCentral billing and admin, two seats up.
ChatGPT Pro 5x$10050 to 500125 to 1,0001,250 to 10,000appliesAll-day agent use on one account.
ChatGPT Pro 20x$200200 to 2,000500 to 4,0005,000 to 40,000appliesParallel sessions and Sol by default.
Two stacked Pro 5x$2002 × 50 to 5002 × 125 to 1,0002 × 1,250 to 10,000two of themA second window. Less weekly than one 20x.
OpenAI API keymeteredno capno capno capnoneCI, automation, an already-burned week.
Continuum Plus$25$25 a week of hosted inference, any model, no window and no per-model capHosted overflow beside your own plan.
Continuum Max 100$100$100 a week, same termsOne plan instead of a plan plus credits.
Continuum Max 200$200$200 a week, same termsPro 20x-shaped load without the window.
Continuum Ultra$500$1,000 a week, same termsThe heaviest Sol-default profiles.

OpenAI publishes the message figures as ranges because cost scales with tokens rather than messages: the low end is an expensive turn against a large repository, the high end a focused one against a single file. Business seats carry the same published per-window figures as Plus and require a minimum of two seats. The weekly limit applies on every subscription rung and OpenAI publishes no number for it, which is why the picker above treats its own weekly figure as the weakest estimate on the page.

04 · Questions

The ones that decide the answer.

Longer versions live in the Codex pricing guide and Codex models.

No. OpenAI sells Pro as 5x or 20x higher rate limits than Plus, not as unlimited Codex. Both Pro tiers still run the same two meters every paid plan runs: a rolling five-hour window that local CLI messages and cloud chats share, and additional weekly limits on top. The only rail with no window and no weekly limit is an API key. What Pro 20x at $200 buys is twenty times Plus on every published model row, which is a large number and a finite one.

Codex tells you the limit is reached and names when it resets. If it was the rolling five-hour window, capacity returns continuously as older activity ages out, so it usually costs you part of an afternoon, and switching to GPT-5.6 Luna, which costs a tenth of Terra per token, often clears it outright. If it was the weekly limit, waiting is longer. Your other options are buying credits, which Plus and Pro accounts can do at the published rate card, or moving that week's work onto an API key, which has no window and no weekly cap.

Model access is nearly identical: Plus at $20 already selects GPT-5.6 Sol, the flagship, so Pro does not unlock a better general model. What Pro buys is headroom. OpenAI publishes Plus at 10 to 100 Sol messages per five-hour window, Pro 5x at $100 at 50 to 500, and Pro 20x at $200 at 200 to 2,000. Pro 20x also adds gpt-5.3-codex-spark, a text-only research preview. Move up when you are meeting the weekly limit, not before.

OpenAI publishes the rate card in credits rather than dollars: 125 credits per million input tokens and 750 per million output on GPT-5.6 Sol, 50 and 300 on Terra, 5 and 30 on Luna. Set those against the API price list and every one of the six figures resolves at four cents a credit, because Sol's 125 credits and its $5.00 per million input are the same number. Codex credits are therefore priced at exact API parity, so overflow is a convenience rather than a penalty.

For one supervised session on Terra most of the working day, ChatGPT Plus at $20 is usually enough, and it is a genuinely low price because the same work metered at API list rates runs to several hundred dollars a month. Sol-heavy work with parallel sessions is where Plus stops surviving the week, and the next rung that does is Pro 5x at $100. Stacking two cheaper accounts is rarely the answer on OpenAI, because its multipliers scale cleanly and one Pro 20x carries more weekly headroom than two Pro 5x accounts at the same $200.

05 · Next month, from data

This tool ran on your estimates.
Continuum runs on your history.

Every number you just typed is a guess about your own behaviour, and people guess badly about it in both directions, especially about which model actually ran. Continuum reads the session files Codex already writes to your machine, attributes every turn to a model id, prices it against the current rate card, and shows what each account consumed by repo, by model, and by day. Next month you pick the plan from data rather than from vibes.

one command · reads local history · sends nothing on its own