Codex Cloud vs Local Cost: GPT-5.3-Codex Pricing Compared

GPT-5.3-Codex is priced at $1.75 per 1M input tokens and $14 per 1M output tokens, with cached input at $0.175 per 1M. For a 12-step agent reference run (4,000-token prefix, 500-token task, each step adding a 300-token tool call and 1,500-token result — 172,800 input tokens and 3,600 output tokens total), that works out to $0.35 uncached and $0.12 when the prefix is cached.

The grounding data does not include a published 'run Codex locally' compute price — there is no local GPU-hour or licensing figure for GPT-5.3-Codex in this data set. What we can price precisely is the API cost per run and the ChatGPT Business subscription baseline at $25/month with $0 marginal per-token cost inside the app. So the real decision most readers face isn't 'API vs bare-metal GPU' — it's 'per-token API/hosted agent vs a flat ChatGPT seat,' and that's what this guide prices out.

Rule of thumb: if your team runs Codex-style agent tasks occasionally (a few dozen runs a day or fewer), the $0.35-per-run API cost is trivial and you should just pay per token. If you have many seats running agent tasks constantly inside ChatGPT's own interface, a $25/month ChatGPT Business seat can beat metering once usage is high enough — but only for work done inside ChatGPT's UI, not raw API calls from your own CI or IDE integration.

All 'per-run' figures in this guide come from the same 12-step reference trace used across our agent cost guides: a 4,000-token system/task prefix, a 500-token task description, and 12 tool-call steps where each step adds a 300-token tool call and a 1,500-token result. Input tokens at step k are 4,500 + 1,800 × (k − 1), totaling 172,800 input tokens across the run, plus 3,600 output tokens.

For GPT-5.3-Codex, that reference run costs $0.35 with no caching, or $0.12 if the growing prefix is cached between steps. The gap between those two numbers — $0.35 vs $0.12 — is the single biggest lever in Codex agent cost, bigger than choosing between GPT-5.3-Codex and its siblings.

GPT-5.1-Codex, a cheaper sibling model, runs the same 12-step trace for $0.25 uncached and $0.09 cached. GPT-5.1-Codex-Mini runs it for $0.05 uncached and $0.02 cached. If your workload doesn't need GPT-5.3-Codex's specific capability tier, those numbers are worth comparing directly against your task quality bar before committing to the pricier model.

Using the GPT-5.3-Codex API directly (or through a hosted agent platform that meters the same way), cost scales linearly with the number of 12-step-equivalent runs you execute:

• 100 runs/day, uncached: 100 × $0.35 = cost scales directly from the per-run figure; at this volume you're spending roughly $35/day before any caching.
• 100 runs/day, fully cached prefix: 100 × $0.12 puts you around $12/day.
• A single developer running Codex a dozen times a day for IDE assistance: 12 × $0.35 uncached is a few dollars a day, trivial next to engineer salary.

These are per-run multiples of the $0.35 and $0.12 figures — we are not inventing new totals, just multiplying the quoted reference-run cost by a run count. For your own workload, plug your actual run count and cache-hit rate into the AI cost calculator rather than trusting a single average.

ChatGPT Business (Team) is priced as a flat $25/month seat with $0 listed marginal per-token cost in this data set — meaning usage inside the ChatGPT product for that seat isn't metered the way raw API calls are. ChatGPT Enterprise and ChatGPT Free are both listed at $0 monthly marginal token cost as well, with Enterprise pricing itself not published in this data set.

The tradeoff: a $25/month seat is a flat cost regardless of how many Codex-style tasks that person runs inside ChatGPT's interface. The API, metered at $0.35 or $0.12 per 12-step run, is a variable cost that scales with usage. For a single moderate user, back-of-envelope: at $0.35 per run uncached, it would take roughly 71 runs in a month to match a $25 seat cost (25 ÷ 0.35 ≈ 71); at the cached rate of $0.12 per run, roughly 208 runs (25 ÷ 0.12 ≈ 208) would match the seat. Below those run counts, pay per token via the API. Above them, and if the work happens inside ChatGPT's own UI rather than a custom integration, the seat can be cheaper.

Note that this comparison only holds for work actually done inside the ChatGPT product tied to that seat. If your agent needs to run inside your own CI pipeline, IDE plugin, or automation server, you need the metered API regardless of seat cost — ChatGPT's flat-rate seat doesn't apply to programmatic access.

The gap between $0.35 and $0.12 per run — a 66% reduction just from caching the prefix — dwarfs most other cost decisions in this comparison. If your Codex agent re-sends a large, mostly-static prefix (system instructions, repo context, tool schemas) across many steps or many runs, structuring your calls to hit the cache is worth more than debating cloud vs local.

For comparison, other models show similar cache multiples on the same 12-step trace: Claude Sonnet 5 goes from $0.38 to $0.11, GPT-5.4 from $0.49 to $0.15, and Gemini 3.1 Pro Preview from $0.39 to $0.12. GPT-5.3-Codex's cached rate of $0.12 lands almost exactly at Gemini 3.1 Pro's cached rate and Claude Sonnet 5's cached rate — caching narrows the field of 'cheap options' considerably.

If you're deciding between a hosted agent (which may or may not expose caching controls to you) and building your own integration against the raw API, the raw API usually gives you more control over cache hit rate, because you control exactly how the prefix is structured and reused.

Cost per token isn't the only variable. A few things this data set can't quantify but that matter to the cloud-vs-local decision:

• Latency: a hosted agent or direct API call adds network round-trips per step; a 12-step run means 12+ round trips unless steps are batched.
• Privacy/compliance: routing code or proprietary data through a third-party API has different compliance implications than a self-managed deployment, regardless of which is cheaper.
• Maintenance: metered API usage requires no infrastructure upkeep on your side; self-managed deployments (if and when available for a given model) add ops overhead that doesn't show up in a per-token price.
• Scaling: metered pricing scales smoothly with usage; a flat seat has a hard capacity ceiling per license.

None of these have grounded dollar figures in this guide, so treat them as decision factors alongside the priced numbers above, not as line items to add to your budget.

All GPT-5.3-Codex and GPT-5.2-Codex rows carry identical rates in this data set. GPT-5.1-Codex-Mini is the cheapest Codex-branded option here, at $0.05 per 12-step run uncached — one-seventh of GPT-5.3-Codex's cost — but check task quality before swapping models purely on price.

• Programmatic/CI/IDE integration: you must use the metered API — a ChatGPT seat doesn't cover this. Budget around $0.35 per 12-step run uncached, $0.12 cached.
• Small team, occasional agent tasks inside ChatGPT's UI: compare your monthly run count against the seat's breakeven (~71 runs uncached, ~208 runs cached, per seat, from the $25 seat price) before paying for a seat.
• High-volume automated agent with a reusable prefix: prioritize prompt caching over any other lever — it cuts the reference run cost from $0.35 to $0.12, a bigger swing than switching model tiers.
• Cost-sensitive prototyping: consider GPT-5.1-Codex-Mini's $0.05 uncached / $0.02 cached run cost while validating the workflow, then upgrade to GPT-5.3-Codex if you need its capability tier.
• Use the AI cost calculator to plug in your actual run volume and cache-hit rate rather than relying on the single reference-run figure.

Pay for the GPT-5.3-Codex API directly if you're building a coding agent into your own pipeline, IDE, or CI system — there's no ChatGPT seat that covers programmatic access, and at $0.35 per run uncached ($0.12 cached) the metered cost is easy to forecast and scale.

Pay for a ChatGPT Business seat at $25/month instead if your team's Codex-style usage happens inside ChatGPT's own interface and a given user's run count comfortably clears roughly 71 runs/month uncached or 208 runs/month cached — past that point the flat seat is cheaper than metering.

Downgrade to GPT-5.1-Codex-Mini ($0.05/$0.02 per run) or GPT-5.1-Codex ($0.25/$0.09 per run) for prototyping or lower-stakes tasks where GPT-5.3-Codex's extra capability isn't worth its higher per-run cost — test task quality first, since none of these figures reflect capability differences.

Whatever you choose, fix your prefix caching strategy before comparing deployment modes further: the cached-vs-uncached gap ($0.35 vs $0.12) is larger than any plausible savings from switching providers or plans.