Codex CLI Token Limit: Check Usage, Plan Limits & Fixes [2026]

How to check your Codex CLI usage

Inside any Codex session, type /status. It shows the model you are on, how much of the context window the current session has used, the percentage of your weekly limit consumed, your 5-hour window if your plan has one, remaining purchased credits, and when each window resets. This is the only number that matters when you are wondering whether to start a big task.

• ✓/status in the Codex CLI: live percentages for the weekly and 5-hour windows, plus reset times and context usage.
• ✓Usage dashboard: chatgpt.com/codex/settings/usage shows the same allowance across the CLI, IDE extension, the Codex desktop app, and cloud tasks, because they all share one pool.
• ✓API-key sign-in: there is no plan limit. Usage is billed per token at API prices and shows up in your OpenAI platform usage page instead.
• ✓Third-party trackers (for example the ccusage codex package) read local session logs. They are handy for history but /status is the source of truth for what OpenAI will actually enforce.

Codex token limits by ChatGPT plan (October 2026)

Codex is included in every ChatGPT tier: Free, Go, Plus, Pro, Business, Education, and Enterprise, and it also works with a pay-as-you-go API key. Limits are not a fixed message count. OpenAI meters tokens and credits, so a long reasoning turn or a task that reads many files burns more of the window than a quick question. The figures below are from OpenAI's own Codex pricing docs and are estimates, not guarantees.

Two things changed in 2026 that older guides miss. First, since April 2 OpenAI meters Codex in credits and tokens rather than counting messages, which is why the same prompt can cost very different amounts depending on how long the model thinks. Second, on July 12 OpenAI temporarily removed the 5-hour limit for Plus, Pro, and Business and reset everyone's usage. The weekly limit still applies, and OpenAI has not said when the 5-hour window returns, so treat /status as the authority rather than any table, including this one.

The model you pick matters more than the plan. On Plus, the docs estimate roughly 350-3,000 messages per window on GPT-6 Luna but only 5-45 on GPT-6 Astra. Running Astra for routine edits is the fastest way to drain a week in a day.

What happens when Codex runs out of tokens mid task

Codex stops the current turn and prints a message along the lines of "You've hit your usage limit. Try again in 4 days 2 hours 46 minutes." The countdown tells you which window you hit: hours means the 5-hour window, days means the weekly one. Nothing is lost. Edits Codex already applied are still in your working tree, and the session transcript is saved, so you can pick the thread back up with codex resume once the window resets.

You have four options at that point:

1. Wait for the reset shown in the message. Weekly windows reset seven days after they started, not on a fixed weekday.
2. Buy credits. Plus and Pro users can purchase additional credits from the usage dashboard and keep working without changing plans. Business and Enterprise workspaces on flexible pricing can add workspace credits.
3. Sign in with an API key instead. Usage then bills at API token prices with no plan window, which is often cheaper than a plan upgrade for a one-off crunch.
4. Cut consumption so the next window lasts. The rest of this guide is about that.

What model_auto_compact_token_limit actually does

Codex keeps the whole conversation (your prompts, its replies, every file it read, every command result) in the context window and resends it on each turn. When that history approaches the model's limit, Codex compacts it: it summarizes the older history into a short recap and continues from there. model_auto_compact_token_limit is the token count at which that compaction triggers. It is a number of tokens, not a percentage, and when it is unset Codex uses the default for the active model.

It lives in ~/.codex/config.toml (Codex uses TOML, not JSON). For example:

Two related keys: model_context_window tells Codex how many tokens the active model can hold, and model_auto_compact_token_limit_scope controls whether the threshold counts the whole context ("total", the default) or only growth since the last compaction. You can also force a compaction at any time with /compact.

Why this matters for your weekly limit: Codex bills the tokens it sends, and it sends the full context every turn. A session sitting at 180k tokens of history costs several times more per message than one at 40k. Setting a lower compaction threshold keeps each turn cheaper at the price of losing older detail in the summary.

Why compaction alone does not fix the burn

Compaction runs after the damage is done. A 12,000-token build log or a 20,000-token file read has already been billed on the turn it arrived, and billed again on every turn until compaction summarizes it away. In a typical Codex session, tool output (file reads, grep results, command output) is the bulk of the context, and most of it is noise: timestamps, blank lines, progress bars, repeated boilerplate.

The fix is to shrink tool output before it enters the context. That is what the Token Limits MCP server does. It gives Codex eight tools (local_read, local_search, local_exec, local_ls, local_json, local_diff, local_map, local_expand) that return compressed results, typically 60-90% smaller, with a local_expand tool to pull the full original when Codex actually needs it.

Install Token Limits for Codex (about 2 minutes)

On macOS or Linux:

1. curl -fsSL https://tokenlimits.app/api/install | bash
2. token-limits setup (paste your license key; the free trial key comes with signup, no card needed)
3. token-limits setup-codex (writes a [mcp_servers.token-limits] entry into ~/.codex/config.toml and leaves your other settings alone)
4. Restart Codex, then type /mcp. You should see token-limits with its eight tools listed.

On Windows, run this in PowerShell. It downloads the native MCP binary, asks for your key, and writes the Codex config for you:

Codex then prefers the compressed tools for reads, searches, and shell commands. Pairing this with a sensible model_auto_compact_token_limit covers both sides: less noise enters the context, and what does enter gets summarized sooner.

Seven habits that stretch a weekly allowance

• ✓Run /status before any large refactor so you are not surprised halfway through.
• ✓Match the model to the task. Use the lighter model for routine edits and reserve the heavy reasoning model for the hard problems.
• ✓Start a fresh session for each unrelated task instead of carrying 100k tokens of old context into the next one.
• ✓Never paste or cat whole logs. Ask for the failing lines, or let a compressed local_exec return the summary.
• ✓Use /compact when a long investigation is over and you are moving to implementation.
• ✓Keep AGENTS.md short. It is loaded into every session, so every line costs tokens on every turn.
• ✓Install Token Limits so file reads, searches, and command output arrive 60-90% smaller by default.

When to upgrade and when to compress