GPT-5: Full Spec Sheet (June 2026)

GPT-5 is OpenAI's first model to ship reasoning, multimodal input, and tool use as a unified, single-model surface rather than three separate endpoints. Where GPT-4o, o1, and o3-mini were three distinct API surfaces in 2024-2025, GPT-5 collapses them: a single `gpt-5` model ID with a `reasoning_effort` parameter (`minimal`, `low`, `medium`, `high`) that scales how many internal reasoning tokens the model burns before answering.

Practically, this means you no longer pick a 'chat model' vs a 'reasoning model'. You pick GPT-5 and dial reasoning effort to match the task. A classification call uses `reasoning_effort: minimal` and bills like GPT-4o. A code-synthesis or math-proof call uses `reasoning_effort: high` and burns several thousand reasoning tokens — billed at the output rate even though they're not returned in the response.

Vision is built in: pass an image URL or base64-encoded image in any user message and GPT-5 will analyze it. Function calling, parallel tool calls, structured outputs (force the model to return JSON conforming to a JSON Schema), and prompt caching are all on by default. The Responses API (`/v1/responses`) is OpenAI's recommended endpoint for new code; chat completions still works for backward compatibility.

The pricing formula is the standard per-token model: `cost = (input_tokens / 1M) × $1.25 + (output_tokens / 1M) × $10`. A representative 1,000-token-in / 500-token-out call: `0.001 × $1.25 + 0.0005 × $10 = $0.00125 + $0.005 = $0.00625`. Roughly 0.6¢ per call.

Apply prompt caching: 80% of a 2,000-token system prompt cached across calls drops 1,600 input tokens from $1.25/M to $0.125/M — saving $0.0018 per call. At 100,000 calls/month, that is $180 off the bill at no quality cost.

Apply the Batch API: a JSONL upload of 1,000 requests with up-to-24-hour delivery runs at $0.625/M input and $5/M output — 50% off both streams. The 1,000-in / 500-out workload drops to $0.003125 per call.

Reasoning tokens are the hidden line item. With `reasoning_effort: high`, GPT-5 can burn 4,000-10,000 reasoning tokens before producing a 500-token visible answer. Those reasoning tokens bill at the output rate ($10/M) but are not returned to you. A high-reasoning call that produces a 500-token answer with 5,000 reasoning tokens bills 5,500 output tokens = $0.055 — 8.8× a no-reasoning call. Budget accordingly. For a full cost walkthrough across the GPT-5 family, see our OpenAI API cost calculator.

GPT-5's 400,000-token context window is combined input + output — not 400K of each. The hard ceiling on output is 128,000 tokens per response, so a maximum-length response leaves 272,000 tokens for input. In practice, most production workloads run with input in the 5K-50K range and output capped well below 4K via `max_output_tokens`, which is the configuration that hits the price-performance sweet spot.

400K is enough to fit roughly a 300,000-word document (≈600 pages of single-spaced text) or a full 1,500-line codebase chunk with metadata. It is less than Gemini 2.5 Pro's 1M window but more than Claude Opus 4.7's 200K. For retrieval-augmented workflows, GPT-5's window is comfortable. For long-document summarization where the entire input must fit in one shot, Gemini 2.5 Pro is the only frontier model with a larger window.

Cap output length always. The default `max_output_tokens` is the model maximum (128K), and a model that decides to ramble can run away in cost. Setting `max_output_tokens: 2000` for a normal Q&A request, `max_output_tokens: 8000` for code generation, and only lifting that cap when the task genuinely needs it (long-form report, full codebase review) is the discipline that separates predictable bills from surprise invoices.

GPT-5 accepts text and images as input. There is no audio input or output on the standard `gpt-5` endpoint (OpenAI's Realtime API uses a separate model for speech-to-speech). Image input is sent as either a URL OpenAI can fetch or a base64-encoded data URL inside a message's `content` array. Each image is billed at a fixed token cost depending on resolution detail (`low` is ~85 tokens, `high` is up to ~1,100 tokens per image for the standard tile size).

Output is text only — no native image generation. To generate images, call `gpt-image-1` (DALL·E 3's successor) or send a tool call from GPT-5 to your image-gen pipeline. For audio, integrate the Realtime API separately or use Whisper for transcription before passing text to GPT-5.

Vision quality on GPT-5 is meaningfully stronger than GPT-4o on charts, diagrams, handwritten text, and multi-image reasoning. It still struggles with very small text (license plates, dense screenshots at low resolution), and as with every vision model, OCR is better handled by a dedicated OCR tool when the volume justifies it.

GPT-5 supports the full function-calling API surface: define tools as JSON Schema, GPT-5 picks one (or several, in parallel) and returns the arguments to call. Parallel tool calls let GPT-5 invoke multiple tools in a single response when it would speed up the task — e.g., fetching two API endpoints simultaneously. This is on by default; pass `parallel_tool_calls: false` to disable.

Structured outputs (introduced in 2024 for GPT-4o, refined in GPT-5) let you pass a `response_format: { type: 'json_schema', json_schema: {...} }` parameter and OpenAI guarantees the model's output validates against that schema. No more parsing free-form JSON and retrying on validation errors. Supports nested objects, arrays, enums, oneOf — the JSON Schema subset that grew across 2025.

The new Responses API (`/v1/responses`) is OpenAI's recommended endpoint for new integrations as of mid-2025. It supports stateful conversations (server-side message storage), built-in tools (file search, web search, code interpreter, computer use), and a cleaner streaming protocol. Chat completions (`/v1/chat/completions`) still works for everything GPT-5 does and remains the lowest-friction path for migrating from earlier GPT models.

GPT-5 exposes a `reasoning_effort` parameter with four levels: `minimal`, `low`, `medium` (default), and `high`. This is the dial that turns GPT-5 from a fast chat model into a slow reasoning model on a single call basis — no separate model ID needed.

`minimal`: near-zero reasoning tokens, fastest response, billed essentially as input + visible output. Use for classification, extraction, simple Q&A, format conversions — anything where the answer is mechanical.

`low`: a few hundred reasoning tokens. The sweet spot for general-purpose chat, content generation, and routine code tasks. Adds <$0.005 per call vs minimal on most workloads.

`medium` (default): typically 1,000-3,000 reasoning tokens. Use for analysis, multi-step planning, code synthesis where correctness matters.

`high`: 4,000-10,000+ reasoning tokens. Use for math proofs, complex code synthesis with strict correctness requirements, legal/financial analysis. Bills 5-10× a no-reasoning call. Most teams over-use `high` and under-use `low`; profile your traffic and right-size each prompt's effort level.

**Pick GPT-5** when output quality is the bottleneck — code synthesis, complex reasoning, multi-step planning, vision tasks with high accuracy requirements, anything that ships to humans where 'good enough' wasn't good enough on gpt-4o. The 8× price premium over gpt-5-mini is justified when downstream cost-of-error dominates per-call cost.

**Pick gpt-5-mini** ($0.25 / $2 per 1M) when you need GPT-5's instruction following and structured outputs but the underlying task is mechanical: classification, extraction, summarization, structured-data transformation, simple chat. Most production workloads with >100K calls/month live on gpt-5-mini.

**Pick gpt-5-nano** ($0.05 / $0.40 per 1M, where available) for embedded use cases — intent routing, content moderation, autocomplete-style suggestions, internal telemetry classification. Avoid for anything requiring multi-step reasoning.

Cross-vendor: pick **Claude Opus 4.7** for long-form writing where Anthropic's voice and refusal calibration matters more than raw IQ; pick **Gemini 2.5 Pro** when you need a 1M context window in a single call or native video understanding. See GPT-5 vs Claude Opus 4.7 for the side-by-side.

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

OpenAI does not version their pricing or model pages with explicit changelog entries. Prices have moved 3-5 times per year on average since GPT-4 launched in 2023, almost always downward as a model matures. Re-verify quarterly if your monthly bill exceeds $1,000 — a single price move shifts the budget materially at scale.

Methodology: when a number could not be cross-confirmed against the official OpenAI page on the verification date, it was omitted from this card rather than guessed. If you find a discrepancy against the live OpenAI page, treat the live page as canonical.