OpenAI API Pricing (2026): GPT-5.6, GPT-5.5, GPT-5.4 and the Full Per-Token Table

The Current OpenAI API Price Table

The table below is the current OpenAI API lineup as listed on the official pricing page, in USD per million tokens at the Standard tier, short-context rate. Input is the cost to send tokens to the model. Cached input is the discounted rate for a repeated prompt prefix. Output is the cost of generated tokens. All figures verified August 21, 2026.

The spread across the lineup is wide. gpt-5.6-luna output at $1.20/1M versus GPT-5.5-pro output at $180.00/1M is a 150x difference, and the older gpt-5-nano at $0.40/1M output stretches it to 450x. That spread is the entire argument for matching the model to the task instead of defaulting every call to the flagship.

How OpenAI Token Pricing Works

OpenAI charges per token, not per request. A token is roughly 4 characters of English text, so 1,000 tokens is about 750 words. Every API call has an input token count (your prompt plus conversation history plus any tool schemas) and an output token count (the model's response). You pay for both at different rates.

Output costs more than input on every model, usually 5x to 6x. gpt-5.6-sol charges $5.00/1M input and $30.00/1M output, a 6x ratio. GPT-5.4 charges $2.50/1M input and $15.00/1M output, also 6x. This asymmetry means a read-heavy workload (summarizing a large document, answering questions about code) is far cheaper than a generation-heavy workload (writing new files, producing long completions) at the same total token count.

Two more dimensions multiply on top of the base rate: the processing tier (Batch halves rates, Fast mode doubles them) and context length (requests past the 272K-token boundary bill the higher long-context rate). Both are covered below.

Processing Tiers: Batch, Flex, and Fast Mode

Every per-token rate above is the Standard tier. OpenAI sells the same models at three other service tiers that multiply the rate: Batch and Flex at half price, Fast mode at double.

Batch runs requests asynchronously and returns results later, at a flat 50% discount on input and output. Flex matches Batch pricing for most models while staying on the synchronous API. Fast mode is the low-latency tier at 2x Standard; it was renamed from Priority processing on July 30, 2026, and the API accepts both service_tier: "priority" and service_tier: "fast". The spread between Batch and Fast mode on the same model is 4x, so classifying which traffic actually needs low latency is itself a cost lever.

Long-Context Pricing

The flagship rows carry two rates: a short-context rate and a higher long-context rate, with the boundary marked at 272K tokens in OpenAI's table. The long-context rate is roughly double on input and 1.5x on output.

The practical takeaway matches Gemini's 200k tier: keep requests under the boundary where you can. Retrieval, compaction, and summarization that hold a request under 272K tokens avoid a 2x input surcharge on the flagship models.

What Happened to GPT-4o and GPT-5 Pricing

Earlier in 2026, GPT-4o and the original GPT-5 family dropped off OpenAI's main pricing table, and this page said so. That has changed: as of August 21, 2026, OpenAI's pricing docs list them again with their own rates, alongside o3 and o1. If you searched "gpt 4o pricing" or "gpt-5 pricing", these are the current published numbers.

The equivalence mapping still holds for capability planning: gpt-5.6-sol and GPT-5.5 sit where GPT-5 sat as the flagship, gpt-5.6-terra and GPT-5.4 cover the general-work tier GPT-4o served, and the mini/nano/luna models cover the small-model tier. The difference is that the older models now stay purchasable at lower rates rather than disappearing.

Cached Input Discount

Cached input is the largest discount OpenAI exposes directly in the price table. When the same prompt prefix repeats across calls, OpenAI charges the cached portion at roughly 10% of the normal input rate on the GPT-5.x families. gpt-5.6-sol cached input is $0.50/1M versus $5.00/1M uncached, a 90% reduction on the repeated prefix.

The cache triggers automatically when a request shares a long identical prefix with a recent prior request. The common pattern: a fixed system prompt, a stable tool schema, and a constant document all live at the front of the prompt, and only the user's latest message changes. The stable front is cached; only the variable tail is billed at full input rate.

To capture the discount, structure prompts so the stable content comes first and the variable content comes last. An agent that rebuilds its system prompt on every turn, or interleaves changing context with fixed context, defeats the cache and pays full input rate on everything. Note the generational difference: the 5.x families cache at 90% off, while gpt-4o caches at only 50% off.

Worked Example: A Coding Session

Assume a coding agent session with 100 LLM calls, each consuming 4,000 tokens (3,000 input, 1,000 output on average). The cost depends entirely on which model handles the calls. The table below prices the same workload across the lineup, with no caching applied.

The all-flagship session costs $4.50. The all-luna session costs $0.18, a 25x difference. Neither extreme is right for a real workload: luna cannot handle the hard 15% of prompts, and gpt-5.6-sol is wasted on the easy 60%. The cheapest correct answer is to route each call to the model that matches its difficulty.

The routed session costs $0.952 versus $4.50 for all-flagship, a 79% reduction, while keeping gpt-5.6-sol on the hard 15% of prompts where quality matters. This is the same arithmetic that makes routing profitable across every provider, applied to OpenAI's current price table.

Monthly Cost Scenarios

Per-token rates are abstract until they become a monthly bill. The table prices three usage profiles over a 30-day month, Standard tier, no caching. Light and medium assume 1,000 input + 300 output tokens per request (a short chat or completion). Heavy assumes an agent workload at 3,000 input + 1,000 output tokens per request.

The arithmetic behind the first cell: 3M input tokens at $2.00/1M is $6.00, plus 0.9M output tokens at $12.00/1M is $10.80, totaling $16.80. Every other cell follows the same two multiplications. Caching a stable system prompt cuts the input side by up to 90%, and moving non-interactive volume to Batch halves the whole number.

ChatGPT Plus vs the API

A recurring budgeting question: is ChatGPT Plus at $20/month or pay-per-token API access cheaper? They are different products. Plus covers the ChatGPT app; the API is billed separately per token no matter what you subscribe to. But the comparison still anchors expectations.

At gpt-5.4 rates, a typical interactive request of 1,000 input + 300 output tokens costs $0.007 ($0.0025 input + $0.0045 output). $20 buys roughly 2,850 such requests, about 95 per day for a month. On gpt-5.6-terra the same request costs $0.0056, roughly 3,570 requests. If your usage is occasional, the API is cheaper than a subscription; if you chat heavily every day and want the app experience, Plus wins on price per message. For programmatic access there is no choice to make: only the API serves it.

Calling the API

The OpenAI API is OpenAI-SDK-compatible. You set the model string, send messages, and receive a response with a usage block that reports exact input and output token counts. Use that usage block to verify your cost estimates against real traffic instead of guessing.

import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.chat.completions.create({
  model: "gpt-5.6-terra",      // $2.00/1M input, $12.00/1M output
  messages: [
    { role: "system", content: "You are a coding assistant." },
    { role: "user", content: "Rename fetchUsers to loadUsers across the file." },
  ],
});

// The usage block reports exact token counts for cost accounting
const { prompt_tokens, completion_tokens } = response.usage;
const inputCost = (prompt_tokens / 1_000_000) * 2.00;
const outputCost = (completion_tokens / 1_000_000) * 12.00;
console.log("Call cost: $" + (inputCost + outputCost).toFixed(6));

Morph exposes the same OpenAI-compatible surface at https://api.morphllm.com/v1. Point the OpenAI SDK's baseURL at it and your existing code runs unchanged, with the router selecting the cheapest sufficient model behind a single endpoint.

import OpenAI from "openai";

// Point the OpenAI SDK at Morph's OpenAI-compatible endpoint
const client = new OpenAI({
  apiKey: process.env.MORPH_API_KEY,
  baseURL: "https://api.morphllm.com/v1",
});

const response = await client.chat.completions.create({
  model: "auto",              // router picks the cheapest model that clears the bar
  messages: [
    { role: "user", content: "Add a docstring to the parseConfig function." },
  ],
});
// Easy prompt routes to a small model; hard prompt routes to a frontier model.
// One endpoint, many providers, 40-70% lower spend.

How to Reduce OpenAI API Costs

Four levers move OpenAI API spend, in order of impact. The first three are structural and apply within OpenAI; the fourth works across providers.

The router lever is the one most teams skip because it sounds like rebuilding their stack. It is not. A router classifies each prompt and returns the cheapest model that clears the quality bar, so the easy work stops hitting the flagship. Morph's router classifies in ~430ms (~$0.001 per classification) and routes across many models through one OpenAI-compatible endpoint at api.morphllm.com, cutting spend 40-70% without touching the rest of your code. See how the LLM router works and the cost calculator.

Frequently Asked Questions

Sources

• OpenAI API pricing docs (developers.openai.com), fetched August 21, 2026

Related Resources

• What Is an LLM Router? Automatic Model Routing for Cost and Quality
• Anthropic API Pricing: Claude Per-Token Table
• Gemini API Pricing: Flash, Pro, and Flash-Lite
• DeepSeek API Pricing
• LLM Cost Calculator
• LLM Cost Optimization
• LLM Gateway: One Endpoint for Many Models
• Multi-Agent Model Routing
• LLM API Comparison
• Best AI Model for Coding