OpenAI API Pricing (2026)

OpenAI's API rate card now covers three GPT-6 flagship models, a set of older GPT-5 models that are still available, separate rates for long prompts, and five processing tiers that charge anywhere from half of list price to six times it. The listed per-token rate is also only part of what a team pays. Reasoning tokens, cache writes, tool calls and re-sent conversation history all show up on the bill without appearing in the response anyone reads.

This guide lays out current OpenAI API pricing by model, explains how each billing mechanic works, compares OpenAI with Anthropic and Google at each tier, and covers how to track OpenAI spend across teams once usage grows.

OpenAI API Rates by Model

OpenAI prices its API per million tokens, with separate rates for input, cached input and output. Every rate in this section is the Standard tier for prompts up to 272K tokens. Longer prompts, batch jobs and faster service tiers change the rate, as covered in the billing section below.

Current flagship models

OpenAI's current lineup is the GPT-6 family. All three models are reasoning models with a 1.05M-token context window and up to 128K output tokens, and their rates are about a hundredfold apart from top to bottom.

The cache write column is new with GPT-5.6 and later models and is explained under cached input pricing below. GPT-6.1 Sol has the deepest cache discount in the lineup, with cached reads at 5% of the input rate instead of the usual 10%.

Earlier models still available

Older GPT-6 and GPT-5 models remain available and are priced on their individual model pages. They're all reasoning models, and several cost more than the GPT-6 model in the same tier.

GPT-5.6 Sol's rate is promotional pricing that OpenAI says runs at least through November 21, 2026. The Pro models offer no cached-input discount and can take minutes per request, so OpenAI recommends running them in background mode.

A larger group of models is deprecated with shutdown dates set. o4-mini shuts down on October 23, 2026. GPT-5, GPT-5 mini, GPT-5 nano and o3 follow on December 11, 2026, and GPT-4.1, GPT-4.1 mini, GPT-4o and GPT-4o mini on January 14, 2027. OpenAI's deprecations page names a replacement for each, and the replacement isn't always the same price. GPT-5 ($1.25 input, $10 output) maps to GPT-5.6 Sol at $4 and $20, while GPT-4o mini maps to GPT-6 Luna, which is cheaper on both input and output.

Embeddings

Embedding models are priced on input tokens only, since they return vectors rather than text. Moderation through omni-moderation-latest is free.

Audio and image

Image and realtime voice models are billed per million tokens, with separate rates for text, image and audio tokens. Transcription is billed per minute of audio.

ChatGPT API vs OpenAI API

There is no separate product called the ChatGPT API. ChatGPT is OpenAI's app, sold as subscriptions, and the API is a developer platform billed per token. The two run on separate billing systems.

Why people search both and what they actually mean

Most people searching for ChatGPT API pricing want to put ChatGPT-style capabilities inside their own product, and the OpenAI API is how they do it. The models behind ChatGPT are available through the API, so the search makes sense even though the name doesn't match a product.

OpenAI does expose the model currently used in ChatGPT as chat-latest, at $5 input and $30 output per million tokens, but labels it as not recommended for API use. Production applications should pin a specific model such as GPT-6.1 Sol so that behavior and price don't change underneath them.

How ChatGPT plans, the API platform and enterprise plans differ

ChatGPT plans charge per user, and the API charges per token. A ChatGPT Plus subscription doesn't include any API usage, and API credits don't unlock ChatGPT features.

For engineering organizations the two usually run side by side: developers use ChatGPT or Codex seats day to day while the product runs on the API. Both count as AI spend, but they arrive on different invoices in different units, which is one reason AI cost visibility gets harder as usage grows.

How OpenAI Bills for Usage

Every API request is billed on the tokens it consumes, multiplied by a rate that depends on the model, the service tier and the length of the prompt. A token is roughly three-quarters of an English word. The mechanics below determine what a given request actually costs.

Input vs output token pricing

Input tokens are everything sent to the model: the system prompt, the user message, earlier conversation turns, tool definitions, and any files or images. Output tokens are everything the model generates, including reasoning tokens the user never sees.

Output costs five times as much as input on all three GPT-6 models and six to eight times as much on several GPT-5 models, so the share of output in a workload matters more than its total token count. A job that reads long documents and returns short answers is mostly an input bill. An agent that writes code or works through a multi-step task is mostly an output bill.

Cached input pricing and automatic caching

OpenAI applies prompt caching automatically. When a request starts with the same prefix as a recent request, the repeated portion is billed at the cached input rate: 10% of the standard input rate on GPT-5.6 and later models, and 5% on GPT-6.1 Sol.

Three conditions decide whether a request hits the cache. The prompt has to be at least 1,024 tokens. The match has to be an exact prefix, so anything that changes early in the prompt (a timestamp, a user ID, a reordered tool list) breaks the cache for everything after it. And the prefix has to be recent. On GPT-5.6 and later models a cached prefix stays reusable for at least 30 minutes after it was last written or used, while GPT-5.5 and earlier models offer an in-memory cache or extended retention of up to 24 hours.

GPT-5.6 and later models also bill cache writes. The first time a prefix is cached, those tokens cost 1.25 times the standard input rate instead of the normal input rate, so a prefix that's written and never reused costs 25% more than it would have uncached. Cached tokens and cache-write tokens appear separately in the usage object (cached_tokens and cache_write_tokens), which is the most direct way to see whether caching is saving money on a given workload.

Service tiers

The same model can be served at different speeds, and each service tier carries its own price. The tier is set per request with the service_tier parameter or as a project default.

Flex is the cheapest way to run work that can wait a few minutes but not a full day. Requests can time out or return a 429 error when capacity is short. OpenAI doesn't charge for a 429 Resource Unavailable error, so the usual pattern is to retry with backoff or fall back to the default tier.

Fast mode, renamed from Priority processing on July 30, 2026, doubles the rate in exchange for responses up to 2.5 times faster and more consistent latency. Traffic that ramps too quickly above 1M input tokens per minute gets served at Standard instead, and billed at Standard rates.

Scale Tier and Reserved Tier are enterprise commitments. Scale Tier sells prepaid token units for one model snapshot with a 30-day minimum and covers models released before GPT-5.6. Reserved Tier covers GPT-5.6 and later: capacity is bought in dollars per minute for a specific model, draws down at list price, and anything over the reservation bills at pay-as-you-go rates.

Batch API

The Batch API cuts the price of both input and output by 50% in exchange for asynchronous processing. Jobs are submitted as a file of up to 50,000 requests, and OpenAI completes them within a 24-hour window, often sooner. Batch traffic uses a separate rate limit pool, so a large backfill doesn't slow down production requests, and if a batch expires before finishing, only the completed requests are billed.

Batch and Flex are priced the same. Batch suits large jobs that can wait up to a day, such as evaluations, embedding backfills and document classification. Flex suits individual requests that need an answer within minutes.

Long-context pricing

When a request has more than 272K input tokens, OpenAI doubles the input and cache rates and raises the output rate by 1.5 times, and the higher rates apply to the entire request, not only the tokens past the threshold. On GPT-6 Astra that moves a request from $10 input and $50 output per million tokens to $20 and $75. The surcharge applies on the Standard, Batch and Flex tiers.

In practice the threshold catches agentic workloads more often than single prompts. An agent that keeps appending tool results to its context can cross 272K partway through a task without anyone deciding to send a long prompt.

Rate limits and usage tiers

Rate limits cap how much an organization can send, measured in requests and tokens per minute and per day, and they're set per model at the organization and project level. Usage tiers set both those limits and a monthly spending ceiling. OpenAI now uses four tiers, and accounts move up automatically based on total credit purchases.

Rate limits don't change the per-token price, but they affect cost indirectly. When a workload hits its limit, requests fail and get retried. OpenAI also counts each request against token limits using the larger of max_tokens and an estimate from the prompt, so a generous max_tokens setting uses up a limit faster than actual consumption would suggest.

How Reasoning Tokens Are Billed

Every current GPT model is a reasoning model, which means part of nearly every request is spent on tokens no one reads. Reasoning tokens are the main reason an OpenAI bill can run several times higher than the visible inputs and outputs suggest.

What reasoning tokens are and why they're billed as output

Before it answers, a reasoning model works through the problem internally, generating tokens that break the task down and test approaches before it writes the final response. OpenAI bills those reasoning tokens as output tokens at the model's full output rate, which is $50 per million on GPT-6 Astra. They also take up space in the context window alongside the input and the visible answer.

Why they don't appear in the response

The API doesn't return reasoning tokens as text, so the response looks shorter than what was billed. The count appears only in the usage object, under output_tokens_details.reasoning_tokens. Comparing that number with the visible output is the quickest way to see how much of an output bill is reasoning.

The max_output_tokens setting caps reasoning and visible output together. If the model spends the whole budget reasoning, the response comes back incomplete, possibly with no visible answer, and the reasoning tokens are still billed. OpenAI recommends reserving at least 25,000 tokens for reasoning and output when starting out. A request that uses that full budget costs about $1.25 in output on GPT-6 Astra, $0.25 on GPT-6.1 Sol and about one cent on GPT-6 Luna.

How reasoning effort settings change the bill

The reasoning effort parameter controls how much a model thinks before answering. Supported values depend on the model and run from none and minimal through low, medium, high, xhigh and max. GPT-6 Astra and GPT-6.1 Sol start at low, GPT-6 Luna supports none, and most current models default to medium. Lower effort produces fewer reasoning tokens and faster responses, and higher effort spends more tokens to work through harder problems.

Effort is set per request, so it can be tuned per feature rather than per application. Classification, extraction and routing calls rarely need more than low effort, while debugging and multi-step research may justify high or above. OpenAI doesn't publish token counts for each level, so the reliable way to price a setting is to run a sample of real requests at two levels and compare reasoning_tokens in the usage data. A team that never sets effort explicitly is paying for medium on every request.

When a reasoning model is worth it

Since every current GPT model reasons, the decision is less about whether to use a reasoning model and more about which model and how much effort. A smaller model at higher effort can match a larger model at lower effort on many tasks for less money. The calculation flips when the smaller model fails often enough that retries and repeated agent steps cost more than the larger model would have.

High effort on a flagship pays off where a wrong answer is expensive: code changes, analysis that feeds a decision, and agent steps where an early mistake carries through every later step. It's harder to justify for high-volume, low-stakes calls such as tagging, summarization and formatting, where GPT-6 Luna at low effort costs a small fraction of a flagship.

Beyond Chat Completions

Text generation is usually the largest line on an OpenAI bill, but embeddings, images, audio and built-in tools each have their own meter, and they add up in workloads that use them heavily.

Embeddings pricing at scale

Embedding costs are low per token but scale with the size of the corpus, and the whole corpus has to be re-embedded whenever the embedding model or chunking strategy changes. Embedding a billion tokens costs $20 with text-embedding-3-small and $130 with text-embedding-3-large.

Embedding backfills are good Batch API candidates, since they rarely need results within minutes. The larger cost of a retrieval system often sits outside OpenAI entirely: vector database storage and query costs grow with the same corpus and show up on a different bill.

Fine-tuning training and inference costs

OpenAI is winding down its fine-tuning platform. New organizations haven't been able to start fine-tuning since May 7, 2026, organizations without recent fine-tuned inference lost access on July 2, and no one can create new jobs after January 6, 2027. Existing fine-tuned models stay available for inference until their base models are deprecated.

The only model still listed for training is o4-mini, at $100 per training hour, with tuned-model inference at $4 input and $16 output per million tokens. But o4-mini and its fine-tuned snapshots shut down on October 23, 2026. Teams that relied on fine-tuning are moving that behavior into system prompts and examples on current models, which makes prompt caching more important, since those longer prompts are sent with every request.

Image, audio and transcription pricing

Image generation with GPT Image 2.5 is billed per token, so the cost of an image depends on its size and quality settings rather than a flat per-image fee. OpenAI's image cost calculator estimates per-image costs, and image output is half price through the Batch API. Older image models are being retired, with gpt-image-1 shutting down October 23, 2026 and gpt-image-1.5 on December 1, 2026.

Realtime voice output is priced well above text, at $64 per million audio output tokens on gpt-realtime-2.1 against $24 for its text output. A long voice session also builds up context that is billed as input on each turn. Cached audio input costs $0.40 per million tokens against $32 uncached, so long sessions depend heavily on cache hits.

Transcription runs from $0.003 to $0.006 per minute for recorded audio and $0.017 per minute for live transcription. Several older audio models, including whisper-1, gpt-4o-transcribe, tts-1 and gpt-4o-mini-tts, have shutdown dates in January and February 2027, and OpenAI points text-to-speech users to gpt-realtime-2.1-mini.

Tool calls in the Responses API

The Responses API is OpenAI's main interface for agents and tools, and since the Assistants API shut down on August 26, 2026 it's where hosted tools run. Built-in tools carry their own fees on top of tokens.

The per-call fees are usually the smaller part. Search results are fed back into the model as input tokens, and every function definition attached to a request is billed as input too, on every request, whether or not the model calls it. OpenAI suggests keeping fewer than 20 functions available at the start of a turn. An agent that loads a large tool library and searches the web at each step pays for all of that context again on every step.

Why Your Bill Exceeds Your Estimate

Most OpenAI cost estimates multiply expected request volume by an average prompt and response size. Production bills rarely match, because several kinds of tokens are billed without showing up in either number.

Retries and failed calls

A request that times out on the client side can still complete on OpenAI's side and be billed, and the retry is billed again. Retries are most common under rate limits, after timeouts on long reasoning requests, and in agent frameworks that retry automatically when output doesn't parse. Responses cut off at max_output_tokens are the same problem in another form: the tokens are billed, the answer can't be used, and the request runs again.

System prompts billed on every request

The system prompt is sent and billed with every request. A 3,000-token system prompt on an application handling a million requests a month adds 3 billion input tokens, which is $30,000 a month on GPT-6 Astra or $300 on GPT-6 Luna before caching. A stable prompt that hits the cache brings that down to about a tenth, which is why system prompts and tool definitions belong at the start of the prompt and anything that varies per request belongs at the end.

Conversation history re-sent as context

Each new turn in a conversation sends the earlier turns back to the model as input. OpenAI's conversation state guide confirms that all previous input tokens in a chained response are billed again as input, even when the Conversations API or previous_response_id manages the history for you. The input cost of each turn grows with the length of the conversation, so the twentieth message in a chat costs far more than the first unless the history is trimmed or summarized.

Reasoning token spend

Estimates built from sample prompts and visible responses leave reasoning out entirely, and reasoning is billed at the output rate. Reasoning volume also varies by input. The same feature can spend little on easy requests and many times more on hard ones, which makes reasoning the least predictable part of an OpenAI bill and the hardest to estimate from a handful of test calls.

Agentic loops without cost ceilings

An agent calls the model repeatedly until it decides a task is done, and each step resends a growing context of instructions, tool definitions, earlier steps and tool results. A loop that gets stuck, or a task harder than expected, can run dozens of steps and cross the 272K long-context threshold along the way. Without per-task limits on steps, tokens or spend, a single run has no cost ceiling, which is why AI agent governance treats budgets and step caps as basic controls.

OpenAI vs Anthropic vs Google

OpenAI, Anthropic and Google now price their lineups in similar bands, and at several tiers OpenAI's and Anthropic's list prices are identical. Google is cheaper at the top of the market but has announced increases for two of its models.

Rates at each model tier

Standard rates per million input and output tokens, for prompts under each provider's long-context threshold:

Tiers follow each provider's own positioning, not benchmark parity. Full model-by-model rates are in the LLM cost comparison and Claude API pricing guides, and the Gemini rates come from Google's pricing page.

Why rate cards alone mislead

Matching list prices don't produce matching bills. Four differences change what the same workload costs on each provider:

• Tokenizers. The same text produces different token counts on different models. Anthropic notes that Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text, so identical per-token rates don't mean identical per-request costs (Anthropic pricing).
• Caching. OpenAI and Anthropic both charge 1.25 times input for a standard cache write, but read discounts differ by model, and Google bills cache storage by the hour on its Pro models. A workload with heavy prefix reuse can rank the providers differently than list prices do.
• Long-context thresholds. OpenAI's surcharge starts at 272K tokens and Google's Pro models change rates at 200K. Anthropic charges flat rates across the full 1M-token window on most models, while Claude Haiku 5.5 reprices the whole request above 100K.
• Reasoning volume. Two models with the same output rate can spend very different numbers of reasoning tokens on the same task, and that difference can outweigh any gap in list price.

The comparison that reflects real costs is cost per completed task on a sample of actual workload, which is the basis of AI unit economics.

Cutting OpenAI API Costs

Most of the mechanics above double as savings levers: using the smallest model and lowest effort that handle each task, keeping prompt prefixes stable so caching works, moving work that can wait to Batch or Flex, trimming conversation history and tool definitions, and capping output and agent steps. Each of these is covered in detail in the guide to reducing OpenAI API costs, and the same levers across providers are in the LLM cost optimization guide.

Tracking OpenAI Spend Across Your Organization

OpenAI's own tools show what an organization spent on OpenAI. Most teams also need to know which product, feature or customer drove that spend, and how it compares with the rest of their AI and cloud costs.

Native usage dashboards and project keys

OpenAI's usage dashboard breaks spend down by project and user, and the Usage and Costs APIs expose the same data programmatically, grouped by project, API key, model and service tier. Projects get their own API keys, model allowlists and rate limits, and spend limits can be set at the organization or project level, either as alerts or as hard limits that reject requests once reached.

The gaps show up once usage spreads. Attribution stops at the project or API key, so a key shared by several features appears as one line. The Costs API reports in daily buckets, and hard limits enforce with a lag that lets spend run slightly past the cap. The data also covers OpenAI only. Anthropic, Google, ChatGPT seats and the cloud infrastructure the application runs on all live elsewhere, and OpenAI models used through Azure or Amazon Bedrock are billed by those clouds and don't appear in OpenAI's dashboard at all.

Attribution by team, feature and customer

Allocating OpenAI spend to teams, features and customers starts on the request side, with a separate project or API key per product or environment and the user field set to identify end users. That covers new traffic. For spend that's already shared, attribution depends on rules that map keys, projects and models to owners after the fact, the same way AI cost tagging works for cloud resources.

Once spend is mapped to a feature or customer, it can be set against the revenue that feature brings in. That is where GenAI cost attribution turns into margin data rather than a cost report.

Anomaly detection on token spend

Token spend can spike within hours: a prompt change that breaks caching, an agent stuck in a loop, a deploy that moves a high-volume feature to a flagship model, or a jump in reasoning effort. Monthly budget alerts catch these after the money is spent. Anomaly detection compares spend by hour, model and project against its own recent baseline, so a change in behavior shows up the same day rather than at month end.

How nOps tracks OpenAI spend

Fully optimizing AI spend means understanding how token consumption, model choice, and application demand affect the broader cloud environment powering them — across AWS, GCP, and Azure, and across every model provider running on top of them.

That's where nOps comes in: helping FinOps teams understand, allocate, and optimize AI token costs alongside the rest of their cloud and AI infrastructure.

• Unified visibility: Get all of your spending from AWS, GCP, Azure, AI, and SaaS in one place, including OpenAI API spend through a direct OpenAI integration. Cost allocation by application, customer, team, or business unit covers spend that was never tagged, with costs broken down by model and token type and hourly anomaly detection on spend that moves off its baseline.
• Commitment Management: Automatically maximize discounts and minimize commitment risk across eligible cloud infrastructure supporting your AI workloads. Customers typically save ~20% by switching to nOps — and with results-based pricing, you pay only when you get better results.

We've talked to companies that can save millions on their cloud bills by switching to nOps from competitors. Book a free savings analysis to quantify exactly how much more you could save across the infrastructure supporting your AI workloads and the rest of your cloud environment.

nOps manages $5B+ in cloud spend and was recently rated #1 in G2's Cloud Cost Management category.

Demo

AI-Powered Cost Management Platform

Discover how much you can save in just 10 minutes!

Book a Demo

FAQ

Answers to common questions about OpenAI API pricing and billing.