Claude Code and Codex do not burn one interchangeable daily token bucket. As of June 30, 2026, the useful control question is narrower: which meter is moving right now, and which contract pays for it?
For Claude Code, that meter may be the local /usage screen, a Pro / Max / Team / Enterprise plan usage bar, Claude Console API spend, a workspace spend limit, or OpenTelemetry exported to your own monitoring stack. For Codex, it may be an included ChatGPT plan window, purchased credits, workspace credits, Fast mode credit burn, image-generation usage, or OpenAI Platform API-key billing.
So do not start with "how many tokens do I get per day?" Start by identifying the tool surface, the plan surface, the model, the context size, and the billing route. Then decide whether to reduce context, switch model, compact, clear, set a spend limit, buy credits, or move a job to API billing.
Evidence note: OpenAI Codex pricing, speed, authentication, slash-command, analytics, and image-generation docs were refreshed on June 30, 2026. Anthropic Claude Code cost, usage, analytics, settings, and OpenTelemetry docs were also checked on June 30, 2026.
Start With The Meter, Not The Upgrade Button
Most bad usage decisions happen because developers mix three questions:
- how much context the agent is reading
- how the product displays remaining plan usage
- where the bill or credit drawdown is recorded
Keep those separate.
| Work surface | First meter to check | Deeper owner | First control move |
|---|---|---|---|
| Claude Code local session on a subscription plan | /usage, status line, and Account & usage in the extension | Claude plan limits and local session history | Clear stale context, compact, lower effort, switch model, disable unused MCP servers |
| Claude Code through API / Console | Claude Console usage and workspace spend limits | API billing and workspace rate limits | Set workspace limits, inspect per-user spend, add OTel metrics |
| Claude Code for a team | Claude analytics dashboard, OTel, gateway, SIEM | Team / Enterprise admin policy | Attribute usage by user, skill, plugin, MCP server, model, and agent |
| Codex with ChatGPT sign-in | Codex usage dashboard and CLI /status or /usage | Included plan window plus optional credits | Use smaller model, compact context, turn off Fast mode unless speed is worth the credit rate |
| Codex with API key | OpenAI Platform billing, limits, and API pricing | Usage-based API contract | Add project spend controls, separate CI / automation from interactive work |
That table is the article's main rule. If the meter is wrong, the next move will also be wrong. Upgrading a plan does not fix a bloated CLAUDE.md, a noisy MCP server, a runaway subagent team, a Codex Fast mode habit, or an API key pointed at the wrong budget.
Claude Code: Read /usage Before You Blame The Plan
Claude Code's cost documentation now makes /usage the first local diagnostic surface. The Session block shows token statistics for the current session. For API users, it is useful for estimating token spend. For Pro, Max, Team, and Enterprise subscribers, the local dollar number is not the authoritative bill; those users see plan usage bars, activity stats, and a breakdown of what counts against plan limits.
That distinction matters. A subscriber should not treat the local dollar estimate as the subscription invoice. An API user should not ignore Console billing because /usage looked small. The safe rule is:
- use
/usageto understand the local session - use plan bars to understand subscription pressure
- use Claude Console for authoritative API billing
- use analytics or OpenTelemetry for team-level attribution
The same screen can also attribute recent usage to skills, subagents, plugins, and individual MCP servers. Claude's docs describe day and week toggles, and the VS Code extension exposes a similar Account & usage dialog on current versions. That makes /usage a triage tool, not just a curiosity.
If Claude Code suddenly feels expensive, check these branches before changing plans:
| Symptom | Likely driver | Control action |
|---|---|---|
| A short prompt consumes a surprising amount | Hidden context, old history, tools, or MCP definitions | Run /context, clear unrelated history, compact with a narrow instruction |
| The session burns fast during planning | Extended thinking, high effort, broad repository exploration | Lower /effort, give exact files, set a clear stop condition |
| Team spend is unclear | Local usage is not enough for attribution | Enable OTel metrics or analytics; segment by user, model, tool, skill, and agent |
| API costs surprise the team | Workspace spend limit is missing or too broad | Set workspace spend limits and lower per-user rate limits where appropriate |
Codex: Separate Plan Windows, Credits, and API Keys
Codex has a different accounting shape. OpenAI's Codex pricing page does not reduce the product to one daily token cap. It separates included plan usage, credits, workspace credits, and API-key billing.
As of June 30, 2026, the visible local-message ranges in OpenAI's Codex pricing table are:
| Codex route | Local messages / 5h | Current table caveat | Control implication |
|---|---|---|---|
| Plus | GPT-5.5: 15-80; GPT-5.4: 20-100; GPT-5.4 mini: 60-350 | Ranges depend on model, task size, complexity, and local context | Use mini for routine edits and keep large repo context out of routine turns |
| Pro 5x | GPT-5.5: 75-400; GPT-5.4: 100-500; GPT-5.4 mini: 300-1750 | Larger included window, not unlimited work | Reserve heavier models for high-risk code paths |
| Pro 20x | GPT-5.5: 300-1600; GPT-5.4: 400-2000; GPT-5.4 mini: 1200-7000 | Highest included tier, still context-sensitive | Watch long-running tasks and background work before assuming a new baseline |
| Business included usage | GPT-5.5: 15-80; GPT-5.4: 20-100; GPT-5.4 mini: 60-350 | Workspace contracts and flexible pricing can change the team story | Admins should check workspace credits, not only the public plan row |
| API key | Usage-based | Standard OpenAI Platform API pricing applies | Treat it as API spend and rate-limit management, not ChatGPT plan headroom |
OpenAI also documents credit rates by model and feature. GPT-5.5, GPT-5.4, GPT-5.4 mini, GPT-Image-2 image paths, and GPT-Image-2 text paths have different input, cached-input, and output credit rates. The practical lesson is simple: a long output-heavy coding run and a short diagnostic prompt do not spend the same number of credits.
Fast mode is another multiplier. OpenAI's speed docs say Fast mode increases speed for supported ChatGPT sign-in sessions but consumes credits at a higher rate. GPT-5.5 Fast mode uses 2.5x the standard credit rate, and GPT-5.4 Fast mode uses 2x. API-key sessions use standard API pricing and do not use ChatGPT Fast mode credits.
Image generation is also not text-only usage. OpenAI's Codex docs say built-in image generation counts toward general Codex usage limits and can use included limits several times faster than text-only work. If your Codex session generates diagrams, UI mockups, or article visuals, do not compare it to a plain code edit.
The Shared Control Loop
Claude Code and Codex have different meters, but the control loop is almost the same.
- Name the job. Is this exploration, editing, review, CI, image generation, or team automation?
- Name the payer. Subscription plan, usage credits, workspace credits, or API key?
- Name the context. Which files, instructions, MCP servers, logs, tools, screenshots, or histories are being loaded?
- Name the model and effort. Heavy models and higher effort are for expensive uncertainty, not for every turn.
- Measure before and after. Check
/usage,/status, dashboards, OTel metrics, Console spend, or Platform billing before changing the contract. - Change one lever at a time. Clear, compact, switch model, disable a server, split the task, then measure again.
This is boring on purpose. A developer who changes five things at once learns nothing. A team that measures the route, model, context, and spend before and after each fix can build a repeatable budget playbook.
Credit And Billing Boundaries You Should Not Mix
The most expensive misunderstanding is treating all "credits" as the same thing.
Claude Code and Codex both talk about usage, limits, and spend, but they are not using one shared ledger. Claude Code API usage is tracked through Anthropic's Console and can be governed with workspace spend limits. Pro and Max plan usage can include subscription usage bars and usage credits. Team deployments may add analytics, OpenTelemetry, gateway attribution, and SIEM logging.
Codex credits are OpenAI-side continuation units for supported Codex usage after included limits or inside flexible workspace contracts. OpenAI Platform API-key billing is a separate usage-based route. A Codex API-key workflow is not spending ChatGPT included plan credits.
Use these stop rules:
- Do not call Claude Code subscription usage an API bill unless Console billing says so.
- Do not call Codex API-key usage an included ChatGPT plan limit.
- Do not treat Fast mode as free speed.
- Do not treat image generation as equivalent to a text-only coding turn.
- Do not infer a new baseline from a temporary dashboard or quota-drain incident until official docs or dashboards settle.
Team Controls: Dashboards, Telemetry, and Spend Limits
Team usage control needs more than local commands.
Claude Code offers analytics dashboards for Team and Enterprise organizations, while API customers can use the Console dashboard for usage and spend. For per-user token counts and cost estimates, Anthropic points teams toward OpenTelemetry export. OTel can expose token usage, cost usage, session counts, tool activity, model attributes, skill names, plugin names, MCP activity, and agent names depending on configuration.
That is the difference between "someone used too much" and "this workflow always burns context because one MCP server, one plugin, and one subagent are loaded for every task." The second version can be fixed.
Codex has its own admin and analytics surfaces. OpenAI's enterprise governance docs say workspace admins and analytics viewers can track adoption and usage, including credit and token usage by product surface and model, with possible data lag. That lag matters when a team is chasing a sudden spike. Do not accuse a workflow before the dashboard, local logs, and billing surface agree.
For both tools, a practical team policy looks like this:
- create separate budgets for interactive development, CI, reviews, and experiments
- require a fresh session for unrelated work
- keep shared instruction files short and push specialized knowledge into on-demand skills
- restrict high-cost models to tasks that justify them
- export usage metrics before the team scales adoption
- define a "stop and inspect" threshold before anyone buys more credits
What To Do When Limits Drain Too Fast
When the meter drains faster than expected, do not upgrade first. Use this order.
| Step | Claude Code action | Codex action | Why it comes first |
|---|---|---|---|
| 1 | Run /usage; check plan bars or Console | Check Codex dashboard and /status or /usage | Confirms which meter moved |
| 2 | Run /context; clear or compact | Compact, start a fresh task, reduce context | Context size is often the cheapest fix |
| 3 | Lower model or effort | Switch from GPT-5.5 to GPT-5.4 or mini when safe | Model mix changes burn rate immediately |
| 4 | Disable unused MCP / plugins / agents | Disable unused MCP / tools / background review loops | Tool overhead can make a small request expensive |
| 5 | Check team telemetry | Check admin analytics and Platform billing | Separates personal session issues from team spend |
| 6 | Only then change contract | Buy credits, raise workspace limit, or move to API billing | Contract changes should follow diagnosis |
There is one extra rule for incident days: if many users report sudden quota drain, treat it as a possible accounting, dashboard, background-work, or retry issue until the official surface is stable. Take screenshots, record the model, context, and task type, then compare against the docs and dashboard after the provider publishes a fix or reset. A single bad day should not become your permanent planning model.
A Practical Budget Checklist
Use this before long agentic sessions.
- Before the run: write the exact goal, files, stop condition, and verification command.
- At session start: check
/usageor/status; confirm model, effort, Fast mode, and API-key route. - During exploration: prefer targeted file reads over whole-repo scans.
- Before long logs: filter test output or delegate noisy work to an isolated subagent.
- Before using Opus, GPT-5.5, or Fast mode: ask whether the uncertainty justifies the burn rate.
- Before image generation: assume it will spend more than a text-only coding turn.
- After the run: record before/after usage and the actual useful output, not just the model name.
The point is not to make agents timid. The point is to spend heavy context on places where heavy context changes the result.
FAQ
Is Claude Code cheaper than Codex?
Not as a universal rule. Claude Code and Codex have different plan contracts, context behavior, model choices, and billing routes. Compare the actual job, model, context size, and payer before judging cost.
Where do I check Claude Code token usage?
Start with /usage in Claude Code. For API billing, use Claude Console. For teams, use analytics or OpenTelemetry so usage can be attributed by user, model, tool, skill, plugin, MCP server, or agent.
Where do I check Codex credit usage?
Use the Codex usage dashboard and CLI /status or /usage for the active session. For API-key workflows, use OpenAI Platform billing and limits.
Does Codex have one daily token limit?
No. Current Codex usage is described through plan windows, model-specific ranges, credits, workspace contracts, Fast mode, image-generation behavior, and API-key billing.
What is the fastest way to reduce usage in both tools?
Start a fresh session for unrelated work, compact useful history, lower model or effort for routine tasks, disable unused MCP servers, and give the agent exact files and stop conditions.
Should I buy credits when limits drain quickly?
Only after diagnosis. If the drain came from a huge context, Fast mode, image generation, a noisy tool loop, or a temporary provider-side incident, buying credits may hide the real problem.
Bottom line: Claude Code and Codex usage control is a meter-routing problem. Identify the meter, shrink the context, choose the right model, then change the billing contract only when the workflow actually needs it.