OpenAI Codex Pricing: Compare Access, API Costs, and Limits

Editorial review and evidence boundary: Flowith Editorial Team consolidated two overlapping pages and reviewed the cited public sources on September 4, 2026. Unless a reproducible test method and result are explicitly shown, comparisons are source-based and are not hands-on benchmarks. Recheck current product documentation, pricing, terms, model availability, and limits before relying on a time-sensitive claim.

Quick answer

Use the official Codex rate card and the Usage panel in Codex for the account’s current pricing state. As of this review, OpenAI says most eligible Plus, Pro, Business, Enterprise, Edu, Health, and Gov customers use a token-based credit rate card; a small subset of Enterprise customers may still be on a legacy rate card.

Do not treat a ChatGPT subscription, Codex credits, and OpenAI API billing as one interchangeable pool. Compare the access path you will actually use, the selected model, token mix, speed setting, included or purchased credits, workspace controls, and the cost of human review and tests.

For workflow and security questions, use the Codex FAQ. For a controlled product trial, use the Codex versus Cursor evaluation guide.

The three pricing questions to separate

1. Does the account have Codex access?

Plan names alone are not enough. Confirm the current account, workspace, seat, region, product surface, and admin settings. Open the Codex Usage panel to see the usage state exposed to that user. Enterprise migrations and workspace policies can create exceptions to a general plan table.

2. How is Codex product usage metered?

OpenAI’s current rate card describes token-based credit usage for most customers. The selected model’s input, cached-input, and output tokens contribute separately. Fast mode can consume credits at a higher rate for supported models, and eligible multi-agent work can use additional tokens.

This means “one message” is not a durable cost unit. A small edit with a focused context can cost much less than a long repository task with broad context, extensive reasoning, multiple agents, retries, and large outputs.

3. Is the task using the OpenAI API instead?

API projects have their own model availability, token prices, rate limits, billing owner, budgets, and usage tiers. A model used inside Codex should not be assumed to have the same identifier, lifecycle, price, or entitlement in the Responses API.

Check the current model page and API pricing before implementation. Pin a documented model where reproducibility matters and design for deprecation or alias changes.

Cost drivers that matter

Driver	Why it changes cost	Control to test
Model	token rates and capability differ	use the least costly model that passes the task rubric
Repository context	more files and history increase input	scope the task and exclude irrelevant generated data
Cached input	eligible repeated context may meter differently	reuse stable context where supported; verify actual usage
Output and reasoning	long patches, explanations, and reasoning consume output	request the artifact and evidence needed for review
Fast mode	supported models can use a higher credit rate	reserve documented Fast access for tasks where elapsed time has value
Ultrafast preview	selected API customers can test GPT-5.6 Sol at provider-reported output speeds	keep it outside Codex budgets unless the exact account, API access, price, and terms are proven
Agents and retries	parallel or repeated work can multiply usage	bound delegation, attempts, and recovery rules
Tests and compute	CI, sandboxes, and external services have separate costs	use staged tests and infrastructure budgets
Human review	accepted code still needs review and validation	track review minutes and escaped defects

A defensible budget test

1. Select 10 to 20 representative tasks from the actual repository.
2. Fix the Codex surface, model, reasoning, speed, repository snapshot, and test policy.
3. Record token or credit usage, elapsed time, attempts, changed files, and test cost.
4. Have reviewers score correctness, security, maintainability, and accepted-task status.
5. Calculate cost per accepted task, not cost per submitted message.
6. Repeat with one cheaper configuration and one faster configuration.
7. Set user, project, or workspace limits and alerts from the observed distribution.

A pilot is not representative if it includes only successful toy tasks. Include ambiguous bugs, failed tests, a multi-file change, a security-sensitive edit, and a task the agent should decline or escalate.

ChatGPT plan and credit checks

Before choosing a consumer or workspace plan, verify:

• whether Codex is available to the exact user and workspace;
• included usage and what happens when it is exhausted;
• whether additional credits can be purchased and by whom;
• how Codex, ChatGPT Work, and other agentic features share usage where applicable;
• current model and fast-mode eligibility;
• workspace role-based controls and spend limits;
• data, retention, training, and connector settings; and
• renewal, cancellation, tax, and regional checkout terms.

For Business and Enterprise, verify the current seat and flexible-pricing rules rather than carrying forward a historical “Team” price. OpenAI’s official materials note that plan and Codex-seat availability have changed over time.

API cost and limit checks

For an API workflow, capture:

• the exact documented model ID and endpoint;
• input, cached-input, and output token rates;
• rate limits for the project’s usage tier;
• batch, tool-call, storage, or other separate charges;
• organization and project budgets and alerts;
• retry, timeout, idempotency, and maximum-output settings;
• logging and retention controls; and
• the migration path for model lifecycle changes.

Rate limits are capacity controls, not a monthly budget. A high RPM or TPM allowance does not authorize that spend, and a budget alert does not stop a request unless an enforced limit is configured.

Keep Ultrafast out of Codex assumptions

OpenAI’s August 13 announcement introduces GPT-5.6 Sol Ultrafast as a limited preview for selected OpenAI API customers. OpenAI reports up to 750 output tokens per second and up to 14× Standard speed, powered by Cerebras.

That announcement does not establish:

• Ultrafast availability inside the Codex product;
• inclusion in a ChatGPT or Codex subscription;
• public API pricing or a credit multiplier;
• a documented request parameter;
• an SLA, fallback, Region matrix, or general-availability date.

Output tokens per second also excludes queue time, input processing, tool calls, network time, and application work. Keep Standard and documented Fast mode as the reproducible budget baselines until the exact Ultrafast access and billing evidence exists for the API project.

Avoid four stale assumptions

“Plus always costs one fixed amount per Codex task”

No. Subscription price, included usage, credit metering, and the usage of a particular task are separate facts.

“ChatGPT API tokens pay for Codex”

Do not assume product and API billing are shared. Confirm both account surfaces independently.

“A task equals a predictable number of tokens”

Repository size, cache behavior, model, reasoning, output, agents, tools, and retries can change usage substantially.

“The cheapest generated patch is the cheapest result”

Include review time, CI, rework, security findings, incidents, and rollback. The useful unit is cost per accepted, safely shipped task.

Frequently asked questions

Is Codex included with ChatGPT Plus or Pro?

OpenAI’s current Codex rate card covers Plus and Pro, but available usage and any additional credits depend on the account and current plan rules. Check Codex Settings > Usage and the official rate card before budgeting.

Is Codex API usage included in a ChatGPT subscription?

Do not assume so. Codex product credits and OpenAI API billing are separate access and metering paths. Verify the API project, model, pricing, rate limits, and organization budget independently.

What determines Codex cost?

The current token-based rate card ties usage to the selected model and its input, cached-input, and output tokens. Workload size, reasoning, agents, fast mode, retries, and review or test cycles can all change total cost.

How should a team estimate a Codex budget?

Run representative tasks with fixed settings, record accepted-task rate and usage, include human review and CI costs, then apply workspace limits and alerts. Do not multiply an old average per-message estimate by task count.

Official OpenAI references

• Codex rate card
• ChatGPT pricing
• OpenAI API pricing
• OpenAI API model documentation
• Business, Enterprise, and Edu flexible pricing
• Codex pay-as-you-go pricing update
• OpenAI: Previewing GPT-5.6 Sol Ultrafast

Last reviewed on August 19, 2026. Recheck the official pages, API project, and account Usage panel before making a purchase or budget decision.