Claude Opus 4.6 vs GPT-5.3-Codex: Costs, Limits, and a Fair Coding Test

GPT-5.3-Codex has lower direct API token prices, while Claude Opus 4.6 offers a larger context window. Neither fact establishes which model will finish your coding task more reliably. For an existing agent or repository workflow, choose between these exact models by measuring accepted work, total usage, and the time needed to repair their changes.

This comparison uses official documentation checked on September 7, 2026. It covers gpt-5.3-codex and claude-opus-4-6, including changes to their documented limits since launch. It does not rank the latest models. If you are choosing an application, editor integration, or subscription, see Claude Code vs Codex: those products include capabilities and constraints beyond one model.

What changes when you switch models?

The clearest documented differences are price, available context, and configuration. Here are the regular API specifications from the GPT-5.3-Codex model page and Claude Opus 4.6 overview.

For GPT-5.3-Codex, use the documented Responses API integration and respect its 272,000-token maximum input, rather than treating the entire 400,000-token context window as available for input. Context and maximum output describe related limits; they do not authorize sending a full window of source text and then requesting another full output allowance.

Opus 4.6's regular output limit is 128,000 tokens. Its documentation also describes a 300,000-token output exception for the Batch API in beta. That exception is relevant to a specifically configured batch workflow; it should not appear as the ordinary interactive coding limit. Anthropic currently documents the full 1M context window at standard rates, so older descriptions of its launch-era long-context beta or premium pricing need to be checked against the current documentation. Anthropic model details, pricing.

A larger context window can change whether a specification, source files, and tool results fit into one request. It does not show that the model uses all those tokens well. Before paying to send more repository content, identify what the task needs: the affected code, its callers, relevant tests, and any behavioral constraints. If that working set fits both models, test both on the same material. If it cannot fit GPT-5.3-Codex's input limit, you have an integration constraint to solve through retrieval, smaller tool responses, or a larger-context model.

Similarly, the name of a reasoning setting is not a common unit of computation. OpenAI's high and Anthropic's high effort should be recorded as separate configurations. Equal labels do not establish equal budgets, latency, or reasoning behavior.

Compare warm requests as carefully as cold ones

A comparison that lists OpenAI's cache discount but leaves Anthropic's cache column blank misses a material part of repeated coding work. Both providers publish lower cache-read rates. Anthropic also distinguishes cache writes by retention period. The following rates are USD per million tokens for standard direct API processing, excluding batch discounts and additional service charges. OpenAI rates, Anthropic cache pricing.

Use separate token categories when adding the bill. In particular, Anthropic cache-write and cache-read tokens should not also be billed as fresh input in your calculation. A repeated prefix does not by itself prove a cache hit: check the provider's returned usage and applicable cache behavior.

Consider an illustrative coding request with 10,000 input tokens and 2,000 output tokens. Holding those counts fixed isolates the published rate difference:

For example, the warm Opus calculation is (2,000 × $5 + 8,000 × $0.50 + 2,000 × $25) / 1,000,000 = $0.064. Creating that 8,000-token cache first would cost $0.110 for the same request with a five-minute write, or $0.140 with a one-hour write. Those are setup-request totals, not amounts to add to every later cache hit.

These figures are arithmetic examples, not measured coding runs. The same source text can tokenize differently across models; generated output, reasoning usage, tool calls, and retries can also differ. Regional or special processing options may add charges. For a real comparison, save each request's billed usage and reconcile the complete task rather than multiplying one assumed request by a success count.

The price gap is useful for budgeting an experiment. It cannot tell you whether Opus will save reviewer time, whether GPT-5.3-Codex will need extra attempts, or whether either will pass your checks. Those are the questions the experiment must answer.

What the public benchmarks can tell you

Both vendors introduced these models on February 5, 2026 and published results for agentic tasks. OpenAI's GPT-5.3-Codex launch appendix reports 77.3% on Terminal-Bench 2.0 and 64.7% on OSWorld-Verified, with the evaluations run at xhigh reasoning effort. Anthropic's Opus 4.6 announcement discusses coding, terminal work, long context, and computer use.

Treat those pages as reports of particular evaluations. Terminal tasks and desktop interaction do not measure the same outcome, and OSWorld is a computer-use benchmark, not a direct measure of code correctness. Tool access, agent implementation, reasoning budget, task version, and scoring rules affect what a result means. A percentage from a launch chart cannot establish that a model will repair your application with less human work.

The practical use of benchmark results is to choose tasks worth testing. A terminal-heavy maintenance workflow should include repository navigation, shell commands, and actual tests. A UI workflow should include browser behavior and visual inspection. A model's ability to produce an attractive screenshot does not establish that form submission works; passing unit tests does not establish that the interface remains usable.

Availability can also change after a launch announcement. For API integration today, use the current model documentation cited above rather than launch text about future access.

Run a comparison that can change your decision

The following is a suggested evaluation protocol; we have not run it as a head-to-head experiment. It is designed to expose differences you can act on in an existing coding workflow.

Start with a small task your team understands well enough to judge independently. For example, use a historical bug where a search page applies an old response after the user changes the query. The accepted behavior should be explicit: results must belong to the latest query, empty and error states must still work, and existing keyboard behavior must remain intact. Keep the known fix out of the model's inputs.

1. Create two isolated checkouts from the same Git commit. Install the same dependencies and give both models the same issue description, relevant files, and local environment. Use fresh sessions so one attempt does not inherit another attempt's solution.
2. Fix the allowed tools and task budget. Give both the same filesystem, terminal, and browser permissions. Set a time or spending ceiling and record the reasoning configuration. If the clients have materially different tools or default instructions, describe the result as a workflow comparison rather than an isolated model test.
3. Write acceptance checks before starting. For the search bug, reproduce out-of-order responses, test an empty query, test a failed request, and confirm the ordinary search path still works. Keep these checks independent of whatever tests the model chooses to add.
4. Run each attempt through the same stopping rule. An attempt ends when it claims completion, reaches the budget, or cannot proceed. Do not quietly grant one model additional repair prompts. If you allow a follow-up round, offer the same type of failure feedback and the same limit to both.
5. Inspect the result and record the full task bill. Run the acceptance checks, inspect changed files, and measure the human work needed to make the change acceptable. A green test command and the model's completion message are starting points for verification.

A compact results sheet can use these columns:

Repeat the comparison on a few task types you actually encounter. A UI change could require a validated form with loading, success, and failure states at desktop and mobile widths. A data task could require repairing a CSV import that mishandles quoted commas, duplicate records, and invalid dates; use fixed fixtures and assert the resulting records. A repository change could span a function signature, its callers, and tests. These tasks reveal different kinds of failure, so preserve their individual results instead of hiding everything inside one average.

For repeated attempts, keep the conditions consistent and record variability. One successful patch is useful evidence about that attempt; it is not a dependable success rate. If caching is important in production, test a separate warm-cache scenario and confirm hits in the usage records. Mixing cold and warm requests without labeling them can make the apparent cost difference misleading.

Make the choice from accepted work

The defensible decision depends on what your tests reveal:

• Both meet the same acceptance criteria with similar review effort: compare actual total cost and completion time. GPT-5.3-Codex's lower published rates are a reason to examine its economics, not to assume equal token consumption.
• Only one passes within your operating budget: use that result for the tested task class and investigate the other model's failure before generalizing.
• Opus handles a necessary working set that exceeds GPT-5.3-Codex's input limit: compare its larger-context approach with the cost of adapting your retrieval and tool outputs. That is a concrete integration tradeoff.
• Results split by task: routing may be useful, but test the routing rule and include its overhead. A failed first attempt followed by a second model can cost more than selecting the successful workflow initially.

A useful accounting measure is total evaluation spend divided by accepted tasks, alongside human repair time. Include failed attempts in the numerator. If you convert reviewer time into money, use your own team's rate and report that assumption separately from the provider bill.

The outcome might be one model for the entire workflow, different models for clearly different tasks, or a decision to keep evaluating. You do not need a two-model architecture to make this comparison worthwhile. You need enough evidence that the chosen setup produces acceptable changes within your time and spending constraints.

Questions that affect setup

Do Claude or Codex subscriptions include these API prices?

The prices in this article describe direct API usage. They are not a subscription comparison or a promise that a particular plan includes a particular API allowance. If you are buying a coding product, compare its current access and usage terms separately; Claude Code vs Codex covers that broader choice.

Does 1M context mean Opus 4.6 can safely understand an entire repository?

It means the documented context window is larger. Whether a repository fits depends on tokenized content and the space required by instructions, tool results, and output. Whether the model understands the relevant behavior still requires checks. Supply task-relevant material and test the result even when the full working set fits.

Which model should I test first if I can afford only one experiment?

Start with the constraint you already know. If the unchanged input genuinely exceeds GPT-5.3-Codex's documented limit, Opus 4.6 can test that larger-context approach. If both fit and your immediate question is whether the lower-priced model meets a fixed acceptance bar, testing GPT-5.3-Codex answers that narrower question. Either experiment can establish suitability for your task; a single-model test cannot establish superiority over the other.