OpenAI API pricing in 2026: every model, explained

What this page actually prices

OpenAI runs two separate pricing systems, and mixing them up is the easiest way to end up confused by a bill. ChatGPT Plus, Pro, and Team are seat subscriptions with a monthly price and a usage quota, the same shape covered in the Codex usage limits guide for the coding-specific version of that quota. The API is different: no seat, no plan, no monthly quota. You get billed per token, for every call, whether it's a script, a coding agent, or an app in production. This page is about that second system: OpenAI's raw per-token API rates as of September 2026, model by model.

If you're pointing an agent at OpenAI directly through its SDK, this is the meter you're actually reading. It has nothing to do with a ChatGPT subscription tier, and it doesn't come with a five-hour window or a weekly cap the way Codex's ChatGPT-plan usage does. It just adds up, call after call, for as long as you keep sending requests.

Current per-token rates, model by model

OpenAI's lineup as of late September 2026 runs from GPT-6 Astra at the top down to small, cheap models built for high-volume, low-stakes calls. Prices below are per million tokens, in and out. They've already moved more than once this year, so treat this table as a snapshot rather than gospel, and check OpenAI's own pricing page before committing a budget to it.

GPT-6 Astra, released September 3, 2026, is still the flagship, and its output tokens cost five times what its input tokens do, a ratio that roughly holds across the lineup: generating text is expensive, reading context is comparatively cheap. On September 22, 2026, OpenAI followed up with GPT-6 Sol and GPT-6 Luna, both priced permanently rather than as a promotion: GPT-6 Sol runs $2/$10, exactly half of GPT-5.6 Sol's old $4/$20 rate, and GPT-6 Luna runs $0.10/$0.50, roughly half of GPT-5.6 Luna's $0.20/$1.20. OpenAI credits caching and inference improvements for the cut, and pitches Sol for recurring coding work and Luna for tightly scoped jobs like summarization and extraction. GPT-5.6 Terra has no GPT-6 successor yet and still sits at $2/$12. Reasoning-heavy o3-pro and o1-pro sit well above everything in this table too, at $20/$80 and $150/$600 per million, aimed at work where getting the answer right matters more than what it costs.

Embeddings run on a separate, much cheaper scale: text-embedding-3-small costs $0.02 per million tokens and text-embedding-3-large $0.13, both input-only since embeddings don't generate output tokens. They rarely show up in a coding agent's bill, but worth knowing if the same API key is also powering search or retrieval.

Cached input, batch jobs, and the long-context surcharge

The list price isn't the only number that moves what you pay. Four levers change the actual bill:

• Cached input. When a request repeats a prefix from an earlier call, a long system prompt, a chunk of codebase context you already sent, the repeated part bills at roughly a tenth of the standard input rate. On GPT-6 Astra that's $1 per million tokens instead of $10, applied automatically. Agents that keep re-sending the same file context turn after turn benefit from this a lot.
• Batch API. Submit a job and accept a result within 24 hours instead of immediately, and both input and output bill at half the standard rate. Good for large offline runs, no use for anything interactive.
• Priority or fast processing. Roughly double the standard rate in exchange for lower, more consistent latency, the inverse trade of batch.
• Long-context surcharge. GPT-6 Astra requests carrying more than about 272,000 input tokens bill the whole request at a higher rate, $20 input and $75 output per million, instead of the standard $10/$50. Pasting an entire large repository into one prompt can cross that line without anyone noticing until the invoice arrives.

What that actually costs on a real coding session

The rates above are easy to read and hard to feel until you run the math on an actual session. Take one turn on GPT-6 Sol, now the more attractively priced mid-tier pick for coding work since its September 2026 cut: 50,000 tokens of file context (mostly cached after the first turn) plus a 3,000-token response. Fresh input at $2/M and output at $10/M works out to roughly $0.13 for that turn, and cached repeats push the input side down further on every turn after the first.

That looks trivial, and for a handful of calls it is. The problem shows up at volume. An agent looping through a large refactor, re-reading files and re-running tests dozens of times an hour, racks up that $0.10-$0.20 per turn with nothing above it to stop it. Point the same workload at GPT-6 Astra instead of Sol and the per-turn cost roughly quintuples on both input and output. There's no monthly ceiling to catch it, the way Claude Code's session-based plans at least cap the damage; the bill is whatever the tokens add up to, which is worth thinking through before defaulting a long-running agent to the flagship model.

Where a flat-rate lane fits next to metered API billing

Per-token pricing is honest, and it's about the only sane way to charge for wildly different call sizes. It also means cost scales open-ended with how much you run, which is fine for the genuinely hard calls and a little painful for the routine, high-volume share of agentic work: rerunning a test suite, grinding through a mechanical refactor, anything a smaller model handles fine but that happens hundreds of times a day.

That's the gap NeverMetered is built for, though it's worth being precise about what it is and isn't. It doesn't serve GPT-6 Astra or any other OpenAI model; it runs Qwen3.8-27B, an open-weight model, on its own dedicated servers, priced by parallel streams (how many requests can generate at once) rather than by the token, with no token quota, no 5-hour window, and no weekly cap on any paid plan. It does speak OpenAI's Chat Completions and Responses APIs, alongside Anthropic's Messages API, on one base URL, so pointing an existing OpenAI-SDK-based agent at it for the routine share of the work is usually a config change rather than a rewrite. Requests over your plan's stream count wait briefly in a fair queue instead of failing or hitting a cap. See current plans for stream counts and a free tier you can try first, or how NeverMetered runs for the model, server, and data-handling details.

It won't replace GPT-6 Astra for your hardest problem, and it isn't trying to. If you're weighing the same question on the Anthropic side, the Claude API pricing breakdown covers the equivalent per-token rates there, and how NeverMetered compares walks through the fuller lineup side by side.