Codex Usage: How to Check Your Limits and Make Them Last

What Does Codex Usage Measure?

Codex usage measures token consumption converted into credits, drawn against a rolling five-hour window on ChatGPT plans. It is not a message counter, and model choice moves it far more than prompt length.

OpenAI's pricing documentation states that model choice, context, reasoning, tool use, retrieval, and caching all affect usage, "so prompt length alone isn't a reliable estimate." Three facts from that page explain almost every "where did my usage go" question:

• One window, two surfaces - local messages and cloud chats share the same five-hour window on ChatGPT plans, and additional weekly limits may apply on top. Delegating a task to the cloud does not buy you a separate budget.
• One pool, four products - Codex, ChatGPT Work, ChatGPT for Excel, and Workspace Agents draw on a shared allowance and credit pool where those features are available on your plan, per OpenAI's guidance on using Codex with your ChatGPT plan. A colleague's spreadsheet agent and your refactor compete for the same allowance.
• Credits, not dollars, are the unit - OpenAI publishes a credits-per-million-tokens rate card and states that GPT-5.6 usage averages 5 to 30 credits per message. Credits let you compare a Luna turn against a Sol turn without touching billing.

One boundary is worth internalizing because it removes a common false alarm. ChatGPT file uploads, image generation, and voice carry separate limits, reset periods, and banners, and OpenAI states plainly that those limits "do not apply to Codex." A "50 images in the last day" banner in ChatGPT tells you nothing about your Codex allowance.

The exception runs the other way. Image generation started inside Codex counts against the same limits as local messages and cloud chats, and consumes them three to five times faster on average depending on image quality and size.

How Do You Check Codex Usage?

Four surfaces show it. Use /usage for the account allowance, /status for the current session, /statusline to pin limits to the terminal footer, and the usage dashboard for credits and reset time.

They answer different questions, so reach for the right one. The account allowance and the session context window are separate numbers, and a session that still has plenty of context can sit behind an exhausted five-hour window.

# Open the usage menu
/usage

# Or jump straight to a view
/usage daily
/usage weekly
/usage cumulative

What Are Codex Limits by Plan?

OpenAI publishes estimated local messages per five-hour window for every model and plan. The ranges are wide because a message is not a fixed unit, but Luna gives 20 to 25 times the messages Sol does.

The plan page carries the detail that catches people out: ChatGPT Work usage inside ChatGPT draws on the same pricing, credits, and usage limits as Codex. Codex itself is included on Free, Go, Plus, Pro, Business, Edu, and Enterprise, so the plan question is about capacity rather than access.

Estimated local messages per five-hour window, from OpenAI's Codex pricing documentation. Cloud chats on ChatGPT plans use GPT-5.6 Sol and may use more of your allowance than local messages. Running Codex on an API key is usage-based instead, with model availability following the API models your key can reach.

Four qualifiers change how you should read that table:

• Business matches Plus - the Business column is identical to Plus for these models, and Enterprise or Edu plans without flexible pricing have the same per-seat limits as Plus for most features. Seat cost and per-seat allowance are separate questions.
• Flexible pricing removes the ceiling - Enterprise and Edu workspaces with flexible pricing have no fixed rate limits; usage scales with credits instead. If your workspace is on that model, the five-hour window is not the constraint.
• Fast mode costs more - speed configurations increase credit consumption for every applicable model, so they burn the included limits faster. The Fast tier is toggled per session with the /fast command.
• Codex-Spark is metered separately - GPT-5.3-Codex-Spark is a research preview for ChatGPT Pro users that runs on specialised low-latency hardware, governed by its own usage limit that may adjust with demand. We benchmarked its output quality in GPT-5.3 Codex Spark vs Claude Opus 4.6.

One retirement is worth planning around: OpenAI has announced that GPT-5.4 and GPT-5.4 mini are being withdrawn from Codex for accounts signed in with ChatGPT, with GPT-5.6 Terra and GPT-5.6 Luna named as the replacements. Workspace defaults, saved model settings, managed configurations, and automations pinned to the old names need updating; the change does not affect the OpenAI API or Codex on your own API key.

When Do Limits Reset?

The five-hour window rolls forward on its own schedule and any weekly limit resets on its own date, both shown in the limit banner and the usage dashboard. Support cannot reset either one for you.

If you hit a limit mid-turn, Codex can finish that turn, subject to fair-use limits. After it ends, you choose from the options your plan offers, which in OpenAI's own framing are: add credits, apply an available reset, upgrade, or wait for the displayed reset time. Eligible Plus and Pro users can buy credits without changing plans, and Business, Edu, and Enterprise workspaces with flexible pricing can buy additional workspace credits. Everyone can also run extra local chats on an API key, charged at standard API rates.

Two things people assume that are not true:

• Support cannot reset your limits - OpenAI states directly that Support does not reset ChatGPT or Codex usage limits. Contact them only if usage looks miscounted, or if access has not returned after the stated reset time.
• A banked reset is not a plan upgrade - some Plus and Pro referral promotions grant a banked rate-limit reset. Using a full banked reset refreshes both the five-hour and weekly windows, but your scheduled weekly reset date does not move, and banked resets expire.

If the numbers themselves look wrong, OpenAI asks for a specific bundle before it will investigate: the limit or credit balance you are questioning, the reset time shown, a screenshot, the Codex client and model, and when it happened including your time zone. Gathering that before you open the ticket is faster than the round trip that follows an incomplete one.

Which Codex Commands Cost Most?

A handful move the meter far more than the rest: /model and /fast set the per-turn rate, /compact reclaims context, /mcp shows the tool context you carry, and codex exec runs a task once.

Running codex --help on Codex CLI 0.149.1 prints the full subcommand surface. The abridged output below is from a real run on this machine, not from documentation:

$ codex --version
codex-cli 0.149.1

$ codex --help
Codex CLI

If no subcommand is specified, options will be forwarded to the interactive CLI.

Usage: codex [OPTIONS] [PROMPT]
       codex [OPTIONS] <COMMAND> [ARGS]

Commands:
  exec              Run Codex non-interactively [aliases: e]
  review            Run a code review non-interactively
  login             Manage login
  mcp               Manage external MCP servers for Codex
  plugin            Manage Codex plugins
  cloud             [EXPERIMENTAL] Browse tasks from Codex Cloud and apply changes locally
  resume            Resume a previous interactive session
  fork              Fork a previous interactive session
  apply             Apply the latest diff produced by Codex agent as a 'git apply'
  doctor            Diagnose local Codex installation, config, auth, and runtime health
  sandbox           Run commands within a Codex-provided sandbox
  update            Update Codex to the latest version
  features          Inspect feature flags

Inside an interactive session, these are the slash commands that matter for usage:

If MCP servers are new to you, the trade-off between a server and a plain command-line tool is covered in MCP vs CLI. For a wider look at how Codex compares to the other terminal agents, see our roundup of agentic coding CLI tools.

How Do You Make Limits Last?

Seven changes do most of the work, and six come from OpenAI's own guidance: match the model to the task, cut prompt and source bloat, shrink AGENTS.md, and disable MCP servers you are not using.

The seventh comes from where the turns actually go: re-prompting an agent that cannot see whether its change works costs more than the change did.

• Match the model to the task - OpenAI positions Sol for complex reasoning and ambiguous problems, Terra as the everyday production workhorse, and Luna for fast, high-volume work like routing, classification, extraction, and focused coding. Renaming a variable across forty files is Luna work.
• Control prompt size - be precise about the instruction and remove context that is not load-bearing. Input tokens are charged per turn, so an oversized preamble is charged again on every follow-up in the session.
• Limit source material - hand Codex only the relevant files, and narrow the sources or date range when possible. Pointing it at a directory when a single module would do multiplies the retrieval cost with no gain in answer quality.
• Shrink AGENTS.md and nest it - the file is injected into your messages, so its size is a recurring tax on every turn. OpenAI advises nesting AGENTS.md files inside a larger repository so each subdirectory carries only the instructions its own work needs.
• Disable MCP servers you are not using - every connected server adds tool definitions to the context of every message. Run /mcp to see what is loaded, and disable the ones this task does not need before you start.
• Define the output before you ask - state the audience, format, and length, and separate required work from optional improvements. An unbounded "improve this" invites the longest, most expensive answer the model can justify.
• Verify the running app outside the agent loop - when Codex cannot tell whether the button it rewired actually works, the cost is not one turn, it is the retry cycle that follows the bug report. Moving that check to a browser agent takes it off the Codex meter entirely.

The fourth and fifth points are in tension with installing agent skills, and the trade-off deserves stating. A skill that teaches Codex to drive a browser earns its context cost several times over because it removes retry turns; a marketplace of skills you never invoke does not. Writing your own is covered in teaching Codex your team's conventions with skills. Install skills at the project level, in that project's AGENTS.md, rather than globally in ~/.codex/AGENTS.md, and the cost lands only on the repositories that need it.

Codex vs Claude Code: How Do the Usage Models Differ?

Both meter a subscription against rolling windows and both are opaque about how a task converts to a unit. Codex is better instrumented in the terminal and more entangled with other products on one pool.

• In-terminal visibility - Codex ships three usage surfaces in the CLI: /usage for the account allowance, /status for the session, and /statusline to pin rate limits and token counters into the footer permanently.
• Shared versus dedicated pool - Codex usage is shared with ChatGPT Work, ChatGPT for Excel, and Workspace Agents where those are on your plan. A Codex allowance is a household budget, not a private one.
• Published per-model ranges - OpenAI publishes estimated messages per five-hour window for each model and plan, which makes the cost of a model switch estimable before you make it rather than after.
• The shared blind spot - both agents reason over source code. Neither renders your application, clicks through the journey, or confirms a redirect lands where it should, so both report "passed" on evidence that never touched a browser.

That last point is the one with a budget attached. A change can pass unit tests and a clean review and still ship a dead button, a form posting to the wrong route, or a console error that only fires in a real browser. Every one of those comes back as a bug report and another round of prompting, on whichever agent you are paying for.

If the turns you are losing are retry turns rather than first-attempt turns, the fix is verification rather than budgeting. TestMu AI's Kane CLI drives the running app in a real Chrome browser from a plain-English objective and returns an evidence-backed pass or fail on its own credits, so the check never touches your five-hour window. See Codex web app testing for the setup, and the Kane CLI skills documentation for the exact AGENTS.md path Codex reads.

Sources and References Used

• [1] Codex pricing, usage limits, credit rate card, and tips for extending limits - OpenAI developer documentation
• [2] Developer commands reference, including /usage, /status, /statusline, /compact and /model - OpenAI Codex documentation
• [3] Using Codex with your ChatGPT plan, covering the shared allowance pool, banked resets, and limit behavior mid-turn - OpenAI Help Center
• [4] Codex CLI version and subcommand output captured from a local run of codex-cli 0.149.1