Same $200, Half the Codex

TL;DR.

On October 30, the $200 ChatGPT Pro plan changes for the people already on it. OpenAI reopened Pro 200 to new subscribers on September 29 with a lower usage allowance, and Codex lead Thibault Sottiaux said the new plan would "net out at half the dollar in API spend." Existing subscribers kept the old allowance through October 29, 2026. After that they move to the new one, at the same $200 a month.

The price is the same and the allowance is smaller. What decides how much work it covers is which model each turn runs on, because Codex now meters included usage in credits per million tokens, and the rate card spans two orders of magnitude:

• GPT-6 Astra costs 100x GPT-6 Luna in credits for the same turn, and 5.9x GPT-6.1 Sol.
• Fast mode bills 2.5x on included usage. Ultrafast bills 8x.
• Moving 60% of Astra turns to GPT-6.1 Sol offsets the cut. Moving half of them to Luna does the same.
• Pro 500 is not a volume discount. At 25x Plus for $500 against a reported 10x for $200, the price per unit of allowance is the same. Pro 500 on Fast mode buys about what Pro 200 buys on Standard.

This post walks through the change, the credit math, a Python script that prices your own Codex week in credits, and a short decision table for the week before the cutoff.

Credit rates are from OpenAI's Codex pricing page as of October 22, 2026. OpenAI publishes no weekly credit allowance for Pro, so allowance figures below are relative and illustrative. The 10x-Plus figure for the new Pro 200 is third-party reporting. No Nadir customer data is used.

What changes on October 30.

OpenAI's help article on Pro tiers says the new Pro 200 allowance is lower "to reflect our increasingly efficient models." Two other details matter for planning. Pro plans have no five-hour limit on Codex, and Sottiaux said it won't come back on the $200 plan, so the weekly allowance is the one you hit. And OpenAI doesn't publish that weekly number. You find it by running out.

We covered the September rename, when "5x" and "20x" turned into "More usage than Plus," in More Than Plus. This is the follow-up: the date is now set, and the meter is in credits.

The meter is credits, and the spread is 100x.

Codex now prices included usage per million tokens, in credits, by model. The Standard-speed rates on OpenAI's pricing page:

Credits per 1M tokens. Codex credit billing has no separate cache-write charge.

Take one ordinary agent turn: 60,000 input tokens, 90% of them cached, and 1,200 output tokens including reasoning. That's a mid-session turn that re-reads the repo context and writes a small diff.

GPT-6.1 Sol's cached input is a twentieth of its fresh input, while Astra's is a tenth. On a cache-heavy turn that widens the Astra-to-Sol gap from 5x on the rate card to 5.9x in practice.

OpenAI's own message estimates point the same way. For Plus, its pricing page gives 5 to 45 local Astra messages per five-hour window, 15 to 160 on GPT-6.1 Sol, and 350 to 3,000 on Luna. The model choice moves the allowance by more than any plan tier does.

Half the allowance, three different weeks.

Say your old Pro 200 allowance covered 1,000 all-Astra turns a week. The number is a placeholder, since OpenAI doesn't publish one. Only the ratios matter. If the new allowance is half, here's what it covers at each mix:

The break-even is simple to state. A halved allowance needs half the credits per turn. Moving a share x of Astra turns to Sol gives 4.35 − 3.615x, which reaches 2.175 at x ≈ 0.60. Moving them to Luna gets there at x ≈ 0.51.

So a developer who runs everything on Astra today, and could move 6 turns in 10 to Sol without noticing, ends up with the same week after October 30 as before. A developer who leaves Fast mode on for every turn has already spent 2.5x more than needed, before the cut.

Whether 60% of your turns can move is a quality question, not an arithmetic one. Renames, test runs, lint fixes, file reads, small diffs, and "what does this function do" usually don't need the flagship. A multi-file refactor or a subtle concurrency bug often does. The point of measuring is to find out which share you actually have.

Pro 500 is a speed plan, not a bulk plan.

The obvious response to a smaller allowance is to buy the bigger plan. Look at what it buys:

• 25x for $500 is 0.05x per dollar. 10x for $200 is also 0.05x per dollar. If both figures hold, upgrading buys more allowance at the same unit price. There's no bulk rate.
• Ultrafast burns 8x on included usage. 25x Plus divided by 8 is about 3.1x Plus of work at Ultrafast speed, roughly a third of what the $200 plan covers on Standard.
• Fast burns 2.5x. Pro 500 run entirely on Fast covers about the same work as Pro 200 run on Standard.

Ultrafast is only offered on GPT-6 Astra and GPT-6.1 Sol, and it's the main reason the $500 tier exists. It's worth paying for on the turns where you're waiting on the answer. It's the wrong default for a background agent working through a test suite. We wrote about the API side of this trade in the GPT-6.1 Sol Ultrafast post.

Tutorial: price your Codex week in credits.

In More Than Plus we read Codex CLI rollout files under ~/.codex/sessions/ and summed each request's token_count event into a usage dict keyed by (week, model). Reuse that loader. This step prices the same totals in credits instead of dollars, because credits are what the allowance is now counted in.

Step 1: the credit rate card.

# Codex credits per 1M tokens, Standard speed: input, cached input, output.
# From OpenAI's Codex pricing page, October 2026. Check it before you trust a total.
CREDITS = {
    "gpt-6-astra": (250, 25, 1250),
    "gpt-6.1-sol": (50, 2.5, 250),
    "gpt-6-sol":   (50, 5, 250),
    "gpt-6-luna":  (2.5, 0.25, 12.5),
}
SPEED = {"standard": 1.0, "fast": 2.5, "ultrafast": 8.0}  # included-usage multipliers

def credits(model, inp, cached, out, speed="standard", as_model=None):
    key = as_model or max((k for k in CREDITS if model.startswith(k)), key=len, default=None)
    if key is None:
        return float("nan")            # unknown model: don't guess
    pi, pc, po = CREDITS[key]
    return ((inp - cached) * pi + cached * pc + out * po) / 1e6 * SPEED[speed]

max(..., key=len) picks the longest matching prefix, so a gpt-6.1-sol turn isn't priced as gpt-6-sol. Codex counts cached tokens inside input_tokens, so subtract them once and don't add them back.

Step 2: your week, and the week with a different mix.

from collections import defaultdict

weeks = defaultdict(lambda: {"turns": 0, "actual": 0.0, "astra_to_sol": 0.0})
for (week, model), (inp, cached, out, calls) in usage.items():
    w = weeks[week]
    w["turns"] += calls
    w["actual"] += credits(model, inp, cached, out)
    # Counterfactual: the same tokens, with every Astra call priced as GPT-6.1 Sol.
    alt = "gpt-6.1-sol" if model.startswith("gpt-6-astra") else None
    w["astra_to_sol"] += credits(model, inp, cached, out, as_model=alt)

for week in sorted(weeks):
    w = weeks[week]
    per_turn = w["actual"] / max(w["turns"], 1)
    print(f"{week}  {w['turns']:>5} turns  {w['actual']:>9,.0f} credits"
          f"  {per_turn:6.2f}/turn  all-Astra-on-Sol {w['astra_to_sol']:>9,.0f}")

The last column is an upper bound: it assumes every Astra turn could have run on Sol. It tells you how much room there is. It doesn't tell you which turns.

Step 3: find your break-even share.

CUT = 0.5   # the new allowance is half the old one, if the reported figure holds
astra = [k for k in usage if k[1].startswith("gpt-6-astra")]
astra_now = sum(credits(m, *usage[(wk, m)][:3]) for wk, m in astra)
astra_on_sol = sum(credits(m, *usage[(wk, m)][:3], as_model="gpt-6.1-sol") for wk, m in astra)
total = sum(w["actual"] for w in weeks.values())

# Assumes your current weeks fill the old allowance. Over 100% means Sol alone can't absorb it.
share = total * CUT / (astra_now - astra_on_sol)
print(f"move {share:.0%} of Astra work to GPT-6.1 Sol to absorb a {CUT:.0%} cut")

On an all-Astra week this prints 60%, matching the table above. On a week that's already 40% Astra and 60% Sol by turns, it prints 75%: the less Astra you run, the larger the share of it that has to move. Past 100%, switching Astra to Sol can't absorb the cut on its own. That's when Luna, less Fast mode, or an API key for overflow comes in.

The week before the cutoff.

One more thing to check: API-key sessions aren't on the plan meter. OpenAI's notes on the GPT-5.5 retirement repeat that Codex sessions authenticated with an API key are billed separately. For a team, a plan for interactive work plus an API key for CI and batch agents is often cheaper than sizing one plan for both.

Choosing the model per turn, without stopping to think.

Every number above assumes someone picks the model for each turn. Nobody does that by hand for long. People choose a model for the session and leave it, and the session runs on Astra because the one hard turn needed it.

That's the gap Nadir's Codex integrations cover:

• Nadir Auto for Codex (nadir-codex-auto) runs the Codex CLI's app-server and, before each turn, asks Nadir's /v1/bucket which model in your Codex model list is the cheapest one that fits the turn. It keeps your configured model when the cache is warm and switching would cost more than it saves, and it keeps it when the decision service is unavailable. Inference uses your existing Codex sign-in. No Nadir gateway is in the path, and prompts aren't stored in its receipts.
• The Codex hook does the same for spawned subagents: it suggests a cheaper tier of your GPT-6 family, with a reasoning effort, for each spawn.

curl -fsSL https://getnadir.com/install/codex-auto.sh | sh
cd /path/to/project
~/.local/bin/nadir-codex-auto

Each turn writes a private receipt to ~/.nadir/codex-auto/receipts.jsonl with the requested and configured model and the usage, which is the data Step 2 needs. Cost figures are estimates. Nadir doesn't guarantee a subscription allowance or task quality, and it keeps your baseline model when it can't price a switch. See the coding-agents page for every install, or start with a free key.

Conclusion.

October 29 isn't the day Codex gets more expensive. It's the day the same $200 covers about half as many credits, if the "half the API spend" figure holds. Credits aren't flat across models: an Astra turn costs about six Sol turns and a hundred Luna turns. A smaller allowance mostly penalizes defaults like Astra for everything and Fast mode left on. Price last week in credits, find the share that can move, and move it before the 30th. If you're still short after that, Pro 500 and an API key cost about the same per unit, and the per-turn model choice is the cheaper fix to try first.

Credit math is illustrative, using an assumed turn profile (60,000 input tokens, 90% cached, 1,200 output) and a placeholder weekly allowance. It is not derived from customer data. Sources: [OpenAI Codex pricing](https://learn.chatgpt.com/docs/pricing) (credit rates, Fast and Ultrafast multipliers, per-model message estimates, no five-hour limit on Pro, GPT-5.5 retirement). [OpenAI DevDay 2026 recap](https://openai.com/index/devday-2026-recap/) (Pro 500 at 25x Plus with Ultrafast). [OpenAI Help Center, About ChatGPT Pro tiers](https://help.openai.com/en/articles/9793128-about-chatgpt-pro-tiers) (lower Pro 200 allowance; grandfathering through October 29). [Thibault Sottiaux on X, September 29, 2026](https://x.com/thsottiaux/status/2104823812042940713) ("net out at half the dollar in API spend"). [Developers Digest, Codex usage limits and pricing in 2026](https://www.developersdigest.tech/blog/codex-usage-limits-pricing-2026) (timeline). [Pasquale Pillitteri, "OpenAI announces Pro $200 is back, with half the API spend for Codex"](https://pasqualepillitteri.it/en/news/19231/openai-pro-200-dollars-back-half-api-spend-codex). The 10x-Plus figure for the new Pro 200 comes from third-party reporting and is not on OpenAI's pricing page.