o3: Full Spec Sheet (June 2026)

o3 is OpenAI's third generation of reasoning model in the post-GPT-4 era — successor to o1 (Sep 2024) and o3-mini (Jan 2025), preceded by the experimental o3-preview that OpenAI quietly retired ahead of o3 GA. The release brought two things that o1 didn't have: production-grade pricing ($2/$8 vs o1's ~$15/$60), and full feature surface (streaming, prompt caching, the standard chat completions endpoint).

Functionally, o3 is a reasoning model in the same lineage as o1 and o1-pro — it produces a long internal chain of thought before writing the visible answer. Reasoning tokens bill at the output rate ($8/M on o3) and are not returned to you. The key behavioral difference from non-reasoning models (GPT-5, Claude, Gemini): you don't scaffold the chain of thought yourself. Prompt o3 with the bare problem statement; the model handles the reasoning structure internally.

o3 has been the production default for reasoning-class workloads on OpenAI since mid-2025. It supplanted o1 entirely (o1 is deprecated for new code as of June 2026) and made o1-pro a narrow-niche tool for the hardest single-call decisions where another 5-10% quality gain justifies a 60× price premium.

Standard rates: `cost = (input_tokens / 1M) × $2 + (output_tokens / 1M) × $8`. The representative 1,000-in / 500-out call WITHOUT reasoning tokens: `0.001 × $2 + 0.0005 × $8 = $0.002 + $0.004 = $0.006`. About 0.6¢ per call — same order of magnitude as GPT-5 ($0.00625 on the same call).

The reasoning-token line item is where o3 differs from GPT-5. A 1,000-in / 500-visible-out o3 call with `reasoning_effort: medium` typically burns 2,000-5,000 reasoning tokens. At $8/M output, 3,000 reasoning tokens = $0.024 — quadrupling the per-call cost vs the same prompt on GPT-5 with `reasoning_effort: low`.

Apply prompt caching: o3 supports automatic prompt caching with the same prefix-first mechanics as GPT-5. Cached input bills at $0.50/M (75% off). For workloads with a stable system prefix, caching cuts the input bill by 60-80% at typical hit rates.

Batch API: 50% off both input and output. Asynchronous reasoning workloads — daily evals, weekly research synthesis, monthly compliance analysis — should always run on batch. The cost stack of caching + batching can bring o3's effective per-call cost below GPT-5's `reasoning_effort: high` cost for the same problem class. Worked $: OpenAI API cost calculator.

o3 exposes `reasoning_effort` with three levels: `low`, `medium` (default), and `high`. Same parameter shape as GPT-5 but without the `minimal` option (reasoning models always reason at least a small amount).

`low`: 500-2,000 reasoning tokens typically. Use for routine problem-solving, structured analysis, code review tasks where the answer is mechanical but benefits from a brief reasoning pass.

`medium` (default): 2,000-8,000 reasoning tokens. The right default for general reasoning workloads — complex code synthesis, multi-step analysis, math problems of moderate difficulty.

`high`: 5,000-30,000+ reasoning tokens. Use for the hardest problems where correctness is the constraint and you've explicitly budgeted for the higher per-call cost. Most teams over-use `high` — profile your actual quality gains before defaulting to it.

Always cap with `max_output_tokens`. The default ceiling (100K total output including reasoning) is a guardrail, not a target. Set explicit caps based on the realistic output budget for the task.

o3 accepts text + image input via the standard OpenAI message format. Vision reasoning on o3 is strong on tasks that require step-by-step interpretation of visual data — chart analysis, multi-step diagrams, complex visual logic puzzles. For simple image classification or single-step VQA, the reasoning premium isn't worth it; use GPT-5 or gpt-5-mini.

Function calling is fully supported via the standard `tools` parameter. Parallel tool calls are on by default. Reasoning models invoke tools within their reasoning chain — o3 can issue a tool call, see the result, reason about it, and issue another tool call before producing the final answer.

Structured outputs (JSON Schema enforcement) work via the standard `text.format` parameter on Responses API or `response_format` on chat completions. Same shape as GPT-5; outputs are guaranteed to validate against the schema.

Streaming is supported — the visible answer tokens stream as they're produced, after internal reasoning completes. The first byte of streaming output typically arrives 2-30 seconds into the call depending on reasoning depth.

**Pick o3** when: the task is structured reasoning at production scale — code synthesis with non-trivial logic, mathematical problem solving, structured analysis with multi-step inference, agentic workflows that need genuine reasoning per turn. o3 is the right default for any 'reasoning-class' workload that runs more than a few times per day.

**Pick GPT-5 with `reasoning_effort: high`** when: you want reasoning quality close to o3 in a model with the full GPT-5 feature surface (broader knowledge, slightly better instruction following on non-reasoning tasks, native multimodal across the same input types). GPT-5 high-reasoning is ~$0.10 per call for the same 1,000-in / 500-out + 5K-reasoning workload that costs ~$0.05 on o3 — comparable order of magnitude. Pick GPT-5 when the task mix is heterogeneous; pick o3 when reasoning is consistently the bottleneck.

**Pick o1-pro** only when: you've benchmarked all three and o1-pro wins on your specific workload by a margin that justifies 30-60× the per-call cost, AND the wall-clock latency (60-180 seconds, no streaming) is acceptable. Narrow use case; most teams don't need it. See our o1-pro spec sheet for the explicit comparison.

If you're on o1 and considering whether to migrate to o3: yes. o1 is deprecated for new code as of June 2026 — OpenAI will eventually sunset it. o3 is dramatically cheaper ($2/$8 vs o1's ~$15/$60), faster, and produces typically equal or better quality on standard reasoning benchmarks.

Migration is trivial: change `model='o1'` to `model='o3'` in your API calls. Same parameter shape, same reasoning-effort dial, same response structure. No prompt rewrites needed for most workloads.

Run a side-by-side eval before the cutover — sample 100-300 production inputs, compare o1 vs o3 outputs, blind-score. Most teams find o3 wins on quality at 13% of o1's price. If your eval shows o3 losing on a subset, that subset goes to GPT-5 `reasoning_effort: high` (much cheaper than o1-pro) or stays on o1-pro for the narrow band where it pencils.

Every number on this page was verified against OpenAI's live documentation on 2026-06-20. Sources: platform.openai.com/docs/models/o3 for context, modalities, and feature support; openai.com/api/pricing for input/output/cached prices; platform.openai.com/docs/api-reference/responses for the Responses API contract.

o3 pricing was cut significantly post-launch (originally $10/$40 per 1M; current $2/$8 reflects a mid-2025 reduction). OpenAI does not publish formal pricing changelogs — watch openai.com/api/pricing directly if your monthly o3 spend exceeds $500. Further reductions are plausible as the reasoning-model architecture matures.

Methodology: when a number could not be cross-confirmed against an official OpenAI page on the verification date, it was omitted from this card rather than guessed.