Codex vs Claude Code Usage Limits (2026)

Short version: at $20, Codex Plus gives you a published 5-hour estimate (15 to 150 GPT-6 Sol messages) plus an unpublished weekly cap, while Claude Pro gives you an unpublished 5-hour session plus an unpublished weekly cap. At $100 and $200, Codex Pro currently has no 5-hour window at all, only a weekly limit, and the $200 tier is closed to new buyers. Claude Max 5x and 20x keep both windows, with the weekly cap 25% above baseline since September 14.

The rest of this page is the plan-by-plan table, what each default model burns, and a script that turns your own logs into a cost-per-task number so you stop guessing.

The plan-by-plan table (September 25, 2026)

Every figure here comes from OpenAI's Codex pricing page, Anthropic's Max plan article, and the dated announcements linked below. Where a vendor publishes no number, the table says so instead of inventing one.

Two things jump out. OpenAI publishes ranges and Anthropic publishes multipliers, so a head-to-head message count is impossible. And the structure of the limit differs more than the size: on Codex Pro today, a heavy Monday eats straight into your week with no 5-hour refill, while on Claude Max a heavy Monday hits the session wall first and refills five hours later.

How the Codex limits work right now

The per-model message estimates

Codex meters by tokens, but OpenAI converts that into estimated local messages per 5-hour window, per model. Cloud chats share the same allowance and "may use more of your allowance than local messages". Weekly limits "may also apply" and have no published number.

GPT-6 Sol and GPT-6 Luna landed on September 22. OpenAI's models page lists Sol as the replacement for GPT-5.4 (retired from Codex on August 31) and GPT-5.5 (retiring October 14), and the desktop app's starting preset is "Sol Light". Note that GPT-6 Sol gets more messages per window than GPT-5.6 Sol on every plan, so the new default is cheaper against the allowance than the one it replaces.

GPT-6 Astra, launched September 3, is the one that burns hard. It is included in the Pro allowance, while Plus gets "limited" Astra with credits for more.

The 5-hour window timeline

This is the part most guides get wrong because it changed three times in ten weeks.

• July 12, 2026: OpenAI temporarily removed the 5-hour window for Plus, Business and Pro. Only the weekly limit applied.
• August 25, 2026: the 5-hour window returned for Plus. Pro $100 and Pro $200 stay exempt "for the upcoming months".
• September 10, 2026: OpenAI paused new sign-ups and upgrades to Pro $200, citing Astra demand. Existing subscriptions renew, and eligible former subscribers get a one-time return within 30 days of losing access (OpenAI Help).

The practical effect of "no 5-hour window" is not "more usage". Users on the OpenAI forum reported the weekly allowance draining at roughly the old 5-hour pace once the window vanished. You lose the natural brake. Pace yourself or you can burn a Pro week in two days.

What burns the allowance faster

OpenAI's own list: model choice, context size, reasoning effort, tool use, and retrieval. Fast mode charges 2.5x the Standard credit rate for Astra, Sol and Luna. Image generation uses limits about 3 to 5x faster. Every MCP server you leave enabled adds context to every message.

How the Claude Code limits work right now

Two windows, one pool

Pro and Max share usage across Claude chat, Claude Code, and Cowork. The session limit resets every five hours. The weekly limit "applies across all models" and resets at a fixed day and time assigned to your account, visible in Settings, then Usage. Max 5x is five times Pro's per-session allowance, Max 20x is twenty times.

There is also a separate model-family meter. If you see "You've hit your Opus limit", switching to Sonnet with /model keeps you working. If you hit the session or weekly limit, switching models does nothing, because those are shared across every model.

The September 14 weekly change

From May 13 through September 13, Anthropic ran a +50% boost on weekly Claude Code limits for Pro, Max, Team and seat-based Enterprise. On September 14 that promo ended and a permanent +25% over the base weekly limit took its place.

Call the old baseline 100. August gave you 150. September 14 onward gives you 125. That is a 25% gain over the pre-May baseline and a 16.7% drop from what you were actually using last month. If your weekly meter started running out on Thursdays this month, that is why. The 5-hour session limit was outside this change.

The September 22 Opus 5.5 change

Eight days later Anthropic shipped Opus 5.5 and, in the launch post, said it is "increasing five-hour usage limits on Pro, Max, Team, and seat-based Enterprise plans" and giving subscribers a rate limit reset "which you can now save and use whenever you choose". No figures were published.

At the same time Claude Code 2.1.280 made Opus the default on Pro and Team Standard, matching Max, and made Opus 5.5 the default Opus. So a Pro user who never ran /model went from Sonnet to Opus 5.5 overnight. Opus draws more allowance per turn than Sonnet, and subagents that inherit the session model inherit Opus too.

What each default model actually costs per token

Subscriptions hide dollars, but the API rate card is the best public proxy for how hard a model leans on your allowance. Here are the list prices per million tokens as of today.

Inside Codex, OpenAI also publishes a credit rate card: GPT-6 Sol costs 50 credits per million input tokens, 5 per million cached, and 250 per million output. GPT-6 Astra is 250, 25 and 1,250. Astra is exactly 5x Sol on every line, which matches the per-window estimates above (Astra tops out at 45 messages on Plus, Sol at 150).

Opus 5.5 and GPT-6 Sol tie on cached input, and caching is where agentic coding spends most of its tokens. That is why the per-task gap between them is smaller than the headline 2x suggests.

Cost-per-task math you can run on your own numbers

The only honest comparison is your task, your token counts. The script below takes a token profile for one task and prices it on each model's API rates and, for Codex models, in credits. It is plain TypeScript with no dependencies, so it runs with npx tsx.

// cost-per-task.ts
// Usage: npx tsx cost-per-task.ts 2000000 0.9 60000
// args: totalInputTokens cacheHitRatio outputTokens

type Rate = {
  name: string;
  inputPerM: number;
  cachedPerM: number;
  outputPerM: number;
  creditsPerM?: { input: number; cached: number; output: number };
};

const RATES: Rate[] = [
  {
    name: "GPT-6 Sol",
    inputPerM: 2.0,
    cachedPerM: 0.2,
    outputPerM: 10.0,
    creditsPerM: { input: 50, cached: 5, output: 250 },
  },
  {
    name: "GPT-6 Astra",
    inputPerM: 10.0,
    cachedPerM: 1.0,
    outputPerM: 50.0,
    creditsPerM: { input: 250, cached: 25, output: 1250 },
  },
  {
    name: "Claude Opus 5.5",
    inputPerM: 4.0,
    cachedPerM: 0.2,
    outputPerM: 20.0,
  },
];

function priceTask(totalInput: number, cacheHit: number, output: number) {
  const cached = Math.round(totalInput * cacheHit);
  const fresh = totalInput - cached;

  return RATES.map((r) => {
    const usd =
      (fresh / 1e6) * r.inputPerM +
      (cached / 1e6) * r.cachedPerM +
      (output / 1e6) * r.outputPerM;

    const credits = r.creditsPerM
      ? (fresh / 1e6) * r.creditsPerM.input +
        (cached / 1e6) * r.creditsPerM.cached +
        (output / 1e6) * r.creditsPerM.output
      : null;

    return {
      model: r.name,
      usd: usd.toFixed(2),
      credits: credits === null ? "n/a" : credits.toFixed(1),
    };
  });
}

const [inputArg, hitArg, outputArg] = process.argv.slice(2);
const totalInput = Number(inputArg ?? 2_000_000);
const cacheHit = Number(hitArg ?? 0.9);
const output = Number(outputArg ?? 60_000);

console.log(
  `Task: ${totalInput.toLocaleString()} input tokens, ` +
    `${Math.round(cacheHit * 100)}% cached, ${output.toLocaleString()} output\n`
);
console.table(priceTask(totalInput, cacheHit, output));

With the defaults (2M input tokens across a multi-turn feature build, 90% cache hits, 60K output tokens), the numbers come out like this:

Read that carefully. It assumes both models use the same number of tokens for the task, which they will not. Opus 5.5 has adaptive thinking that cannot be turned off (thinking bills as output), and GPT-6 Sol at High effort can think far longer than at Medium. The script gives you the price of a token profile. Your logs give you the profile.

Cache writes are left out for simplicity. Opus 5.5 charges $5 per million for a 5-minute cache write, and GPT-6 Sol charges $2.50, so a task with lots of fresh context shifts a little further toward Sol.

Pull real token counts out of Claude Code

Claude Code writes every session as JSONL under ~/.claude/projects/, and each assistant message carries a usage object with input, output, cache-read and cache-creation token counts. The script below sums those per session so you can feed real numbers into the calculator above.

// claude-session-tokens.ts
// Usage: npx tsx claude-session-tokens.ts [daysBack]
import { readdirSync, readFileSync, statSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";

type Usage = {
  input_tokens?: number;
  output_tokens?: number;
  cache_read_input_tokens?: number;
  cache_creation_input_tokens?: number;
};

type Totals = {
  session: string;
  fresh: number;
  cacheRead: number;
  cacheWrite: number;
  output: number;
};

const root = join(homedir(), ".claude", "projects");
const daysBack = Number(process.argv[2] ?? 7);
const cutoff = Date.now() - daysBack * 24 * 60 * 60 * 1000;

function sessionFiles(dir: string): string[] {
  const out: string[] = [];
  for (const entry of readdirSync(dir)) {
    const full = join(dir, entry);
    const info = statSync(full);
    if (info.isDirectory()) out.push(...sessionFiles(full));
    else if (entry.endsWith(".jsonl") && info.mtimeMs >= cutoff) out.push(full);
  }
  return out;
}

function sumFile(file: string): Totals {
  const totals: Totals = {
    session: file.replace(root, "").slice(1, 60),
    fresh: 0,
    cacheRead: 0,
    cacheWrite: 0,
    output: 0,
  };
  for (const line of readFileSync(file, "utf8").split("\n")) {
    if (!line.trim()) continue;
    let row: { message?: { usage?: Usage } };
    try {
      row = JSON.parse(line);
    } catch {
      continue;
    }
    const u = row.message?.usage;
    if (!u) continue;
    totals.fresh += u.input_tokens ?? 0;
    totals.cacheRead += u.cache_read_input_tokens ?? 0;
    totals.cacheWrite += u.cache_creation_input_tokens ?? 0;
    totals.output += u.output_tokens ?? 0;
  }
  return totals;
}

const rows = sessionFiles(root)
  .map(sumFile)
  .filter((t) => t.output > 0)
  .sort((a, b) => b.output - a.output)
  .slice(0, 15);

for (const t of rows) {
  const input = t.fresh + t.cacheRead + t.cacheWrite;
  const hit = input > 0 ? t.cacheRead / input : 0;
  console.log(
    `${t.session}\n  input ${input.toLocaleString()}  ` +
      `cache hit ${(hit * 100).toFixed(0)}%  ` +
      `output ${t.output.toLocaleString()}`
  );
}

Take a session that represents "one normal feature", plug its input total, cache-hit ratio and output into cost-per-task.ts, and you have a real per-task price for Opus 5.5 and the GPT-6 Sol equivalent. On Codex, the CLI's /usage daily view gives you the matching token activity for the same kind of task.

Check your meter from inside each CLI

Both tools now show plan usage without leaving the terminal. Here is what each command does, verified against the current docs.

# ---- Codex CLI ----
# Active model, approval policy, token usage for this session
/status

# Account token activity, or redeem an earned rate-limit reset
/usage
/usage daily
/usage weekly
/usage cumulative

# ---- Claude Code ----
# Session cost, plan usage limits, and what counts against them
# (/cost and /stats are aliases)
/usage

# Options when a limit blocks you: wait and auto-continue,
# add usage credits, or upgrade
/rate-limit-options

# See and switch the model (Opus limit is separate from the session/weekly pool)
/model

Run the usage command at the end of three normal working days before you decide to change plans. Being annoyed once is not the same as being blocked daily.

Pin the model so defaults stop surprising you

Both vendors changed defaults this month. Pinning the model means a CLI update cannot quietly move you to a hungrier one. For Codex, the model and reasoning effort live in ~/.codex/config.toml, which the desktop app, CLI and IDE extension all share.

# ~/.codex/config.toml
model = "gpt-6-sol"
model_reasoning_effort = "medium"

OpenAI recommends starting Sol at Medium, Luna at High, and Astra at Light (low in config). Reach for Astra per task with codex -m gpt-6-astra instead of making it the default, since it burns roughly 5x Sol's credits.

For Claude Code, set a default in your user settings. Pick Sonnet if most of your work is routine and you want the weekly pool to last, or keep Opus 5.5 and switch down when needed.

{
  "model": "claude-opus-5-5"
}

Save that as ~/.claude/settings.json (merge it with any keys already there). You can override it per launch with claude --model claude-opus-5-5, or use /model opusplan to plan with Opus and execute with Sonnet.

Which plan for which developer

At $20. Codex Plus is the more predictable plan right now because OpenAI publishes a per-window range and GPT-6 Sol got cheaper against the allowance. Claude Pro now opens on Opus 5.5, which draws more of the session per turn than the old Sonnet default. If you live in Claude Pro, switch to Sonnet for execution work.

At $100. This is the tier that matters most this month, because it is the highest one both vendors will sell a new customer. Codex Pro 5x has no 5-hour window, so it rewards bursty developers who do a lot on two or three days. Claude Max 5x keeps both windows, which suits steady daily use and makes it harder to torch your week by Tuesday.

At $200. If you already hold Codex Pro 20x, do not cancel or downgrade casually: you get one return within 30 days, then you wait for the pause to lift. If you are shopping new, the choice is Claude Max 20x or Codex Pro 5x plus credits.

Past the cap. Codex Plus and Pro can buy credits without changing plan, and any user can run extra local chats against an API key at API rates. Claude Pro and Max can enable usage credits, or switch Claude Code to a Console API key (setting ANTHROPIC_API_KEY overrides your subscription entirely, so unset it when you want plan billing back).

Frequently asked questions

Does Codex have a 5-hour limit in September 2026?

On Plus, yes. OpenAI suspended the 5-hour window for Plus, Business and Pro on July 12, 2026, then brought it back for Plus on August 25. Pro $100 and Pro $200 stay without the 5-hour window for now, so on those plans only the weekly limit applies.

Can I still buy the $200 Codex Pro plan?

Not as a new subscriber. Since September 10, 2026 OpenAI has paused new sign-ups and upgrades to Pro $200 (Pro 20x), including upgrades from Plus and Pro $100. Existing Pro $200 subscriptions keep renewing, and Pro $100 is unaffected.

What changed with Claude Code weekly limits on September 14, 2026?

The temporary +50% weekly boost that ran from May 13 through September 13 ended, and a permanent +25% over the base weekly limit started on September 14 for Pro, Max, Team and seat-based Enterprise. For anyone used to the promo, that is roughly 17% less weekly headroom than in August.

How do I check my remaining usage in Codex and Claude Code?

In the Codex CLI, /status shows the active model and token usage, and /usage shows daily, weekly or cumulative token activity and lets you redeem an earned reset. In Claude Code, /usage (aliases /cost and /stats) shows session cost, plan usage limits and what counts against them.

Is GPT-6 Sol cheaper to run than Opus 5.5?

Per token, yes. On the API, GPT-6 Sol is $2 input and $10 output per million tokens, while Opus 5.5 is $4 and $20. Cache reads cost $0.20 per million on both. On a subscription you pay in allowance instead of dollars, and Plus is estimated at 15 to 150 GPT-6 Sol messages per 5-hour window.

Posted by @speedy_devv