Why I care about the multipliers more than the rates
I build integrations and APIs at eesel. For a support workflow, I want to know more than the price of one model call: how much context each request includes, which tools it uses, and how that work is billed.
Our February 2026 sales notes describe an email-security company on Freshdesk scaling toward 20,000 tickets a year. The buyer reported using 200 API calls in one test day and worried about costs at an expected 9,000 interactions per month. That is a historical concern about testing volume, not an OpenAI invoice or evidence that a particular prompt size caused the cost. I would first establish the billing unit before extrapolating a trial to a production budget.
That is the whole reason this post is structured the way it is. The rate card comes first because you asked for it, and then the four things that actually move it, because those are what I would look at if you handed me your invoice and asked why it was double last month.
Selected OpenAI API model prices
The following selected model rates are per 1M tokens in USD, checked against OpenAI's pricing page on September 8, 2026. This table uses Standard short-context rates; the official page also lists older models and specialized services.
| Model | Input | Cached input | Cache write | Output | Context window | Max output |
|---|---|---|---|---|---|---|
gpt-6-astra | $10.00 | $1.00 | $12.50 | $50.00 | 1,050,000 | 128,000 |
gpt-5.6-sol | $4.00 | $0.40 | $5.00 | $20.00 | 1,050,000 | 128,000 |
gpt-5.6-terra | $2.00 | $0.20 | $2.50 | $12.00 | 1,050,000 | 128,000 |
gpt-5.6-luna | $0.20 | $0.02 | $0.25 | $1.20 | 1,050,000 | 128,000 |
gpt-5.6-cyber | $12.50 | $1.25 | $15.625 | $75.00 | 400,000 total; max 272,000 input | 128,000 |
chat-latest | $5.00 | $0.50 | not listed | $30.00 | not listed | not listed |
gpt-5.3-codex | $1.75 | $0.175 | not listed | $14.00 | not listed | not listed |
gpt-5.6 is an alias that routes to Sol. Sol, Terra and Luna share a February 16, 2026 knowledge cutoff and accept reasoning.effort of none, low, medium (the default), high, xhigh and max, per their model documentation. Astra has its own specifications; do not apply the GPT-5.6 defaults to it. Our OpenAI models list covers the wider lineup.
Two rows deserve a note. gpt-5.6-cyber, the Daybreak Red model, lists $12.50 input and $75 output, with no long-context pricing band on the card. Those rates are 3.125x and 3.75x Sol's current promotional input and output rates respectively. Our GPT-5.6 Cyber pricing guide covers that model. Meanwhile, chat-latest lists $5 input and $30 output, so it no longer shares Sol's current rates.
The aliases gpt-daybreak-blue-latest and gpt-daybreak-red-latest currently point at gpt-5.6-sol and gpt-5.6-cyber. OpenAI says their targets and prices will change as newer models enter the program. Using a moving alias therefore does not lock a model version or price.
The 30 July repricing changed where you put model calls
The OpenAI changelog records an 80% Luna price reduction and a 20% Terra reduction from July 30, 2026. Their current Standard short-context rates are $0.20/$1.20 and $2/$12 respectively. Sol's later promotional rates are reflected separately in the current table above. A Hacker News commenter reacted to the Luna cut:
"80% price cut for luna is a very aggressive pricing move"
An AI Builders post highlighted the resulting gap between Luna and Terra:
"Luna and Terra now sit 10x apart on both input and output, where the gap was 2.5x."
At the current listed rates, Terra's input and output prices are each 10x Luna's. That makes Luna worth evaluating for suitable workloads, but does not prove that a team using Terra is overpaying: accuracy, token consumption and latency can differ. One commenter describing internal benchmarks on the Gemini 3.7 Flash thread reported:
"Then gpt-5.6-luna came along with the price cuts and immediately supplanted gpt-5-mini."
Service tier and context band change the rate
For Astra, Sol, Terra and Luna, the pricing page lists four service tiers and two context bands. Each combination has separate input, cached-input, cache-write and output rates. Other models have different availability; do not apply this layout to every row on the page.
| Cost factor | What changes | What to measure |
|---|---|---|
| Service tier | Input and output rates for the selected tier | Effective tier on each request |
| Context band | Full-request rates above the model's threshold | Total input tokens per request |
| Cache state | Input rates only: ordinary input, reads or writes | Tokens billed in each input category |
| Reasoning | Billed output quantity, not a separate rate multiplier | Reasoning tokens as well as visible output |
On output alone, gpt-5.6-sol runs from $10.00 per million tokens (Batch, short context) to $60.00 (Fast mode, long context). That is a 6x difference in the output rate across tier and context-band combinations, not a claim that the same prompt belongs in both context bands. At Standard short-context rates, cached input costs $0.40 per million tokens and cache writes cost $5.00. These are the current promotional Sol rates, available at least through November 21, 2026.
I would compare the model and service tier together. For example, these rates are all per million tokens:
| Configuration | Input | Output |
|---|---|---|
gpt-5.6-sol on Batch, short context | $2.00 | $10.00 |
gpt-5.6-terra on Fast mode, short context | $4.00 | $24.00 |
gpt-5.6-terra on Fast mode, long context | $8.00 | $36.00 |
At short-context rates, Terra on Fast mode costs 2x Sol on Batch for input and 2.4x for output. Moving from Sol Batch to Terra Fast can therefore increase token costs despite choosing a cheaper model. Changing only the model while keeping the same tier is a different comparison. Batch also has different latency requirements, so I would check whether the workload can wait before treating it as an interchangeable option.
The 272K cliff
The pricing page separates short- and long-context rates. The GPT-5.6 Sol model page explains when the higher band applies:
Prompts with >272K input tokens are priced at 2x input and 1.5x output for the full request.
Three things follow from that, and all three matter.
First, the threshold is 272,000 input tokens, not the 1,050,000-token context window the marketing leads with. You get roughly a quarter of the advertised window at the advertised price.
Second, it reprices the full request, not the overflow. At current Sol Standard rates, a 272,001-token prompt with no cached input bills all its input at $8 per million tokens, not 272,000 tokens at $4 and one at $8. Cached reads and writes have their own long-context columns too.
Third, it moves output as well, at 1.5x, even though the length of your reply has nothing to do with how long the prompt was.
The pricing table and model page should be read together. Korbinian Abstreiter’s LinkedIn post describes being surprised by the threshold:
"Still didn't expect it"
I would check for redundant context before crossing 272K, then test whether compaction preserves the information needed to answer correctly. A lower token bill is not a useful saving if it removes essential evidence.
A Hacker News discussion connects Codex context settings with long-context charges. One commenter offered this explanation:
"It cost people a LOT of money."
That is the commenter’s account, not an official explanation of the product decision. It does not establish OpenAI’s motives or the current Codex default. For this API budget, the relevant check is the input-token count and pricing band of each request.
A simplified quadratic-attention calculation is not a measurement of a provider’s serving costs. Architecture, caching and hardware also matter, so it cannot establish why OpenAI chose this pricing step. The threshold itself is explicit; one commenter questioned its abrupt shape:
"I'm actually surprised it's implemented as a hard cutoff instead of a smooth gradient."
The rate-limit guide describes separate limits for long-context requests. Check the applicable limits in your developer console; a separate pool does not by itself establish lower throughput. Our OpenAI rate limits guide explains the related limits.
Context-dependent pricing is not unique to OpenAI, but the thresholds differ. The Grok 4.6 model page lists higher-context pricing above 200K, not OpenAI's 272K boundary. Check each provider's model-specific table rather than treating those surcharges as equivalent. Our Grok 4.6 pricing guide covers that model separately.
What the cliff costs in a hypothetical workload
Take a hypothetical retrieval answer bot on Sol: 40,000 input tokens per request, 900 billed output tokens, 30,000 requests a month, 50% of input billed as cached. That is $3,180 a month on Standard for tokens alone, excluding cache writes, tool charges and regional processing fees.
Now suppose someone widens the retrieval window and each request carries 300,000 input tokens instead. Same model, same tier, same volume.
| Input tokens per request | Band | Monthly cost |
|---|---|---|
| 40,000 | short | $3,180 |
| 271,000 | short | $18,426 |
| 300,000 | long | $40,410 |
In this example, trimming the prompt from 300,000 to 271,000 tokens reduces the estimated monthly token cost from $40,410 to $18,426. That is about 54% less for removing 29,000 input tokens per request. I would first test whether the removed context affects answer quality. This saving depends on the workload crossing the pricing threshold; it does not establish that context trimming always beats changing models.
A post on r/openrouter describes a local cost estimate that differed from the provider dashboard. The author pasted an LLM-generated explanation, including this claim:
"Approximately 221 requests exceeded the 272K threshold."
The author reported about $1.35 in OpenCode and $2.30 in OpenRouter. The $2.297 reconciliation and 221-request count came from the pasted model response, not an independently verified usage export. I would treat that as a lead to check against provider records, not proof of the calculation. It also concerns OpenRouter pricing, not a direct OpenAI invoice.
Prompt caching gives you 90% off and a 25% penalty
At current Sol Standard short-context rates, cached input costs $0.40 per million tokens against $4.00 uncached, a 90% discount. Cache writes cost $5.00 per million tokens, 1.25x the uncached input rate. The prompt caching guide distinguishes ordinary input, cache reads and cache writes; I would account for all three rather than apply a single discount to the prompt.
The caching guide distinguishes GPT-5.6 and later models, which charge for cache writes, from earlier models without that additional charge. One commenter noticed the difference when comparing the model pages:
"There was no cache write before!"
"Anyway this does mean the "real" prices are +25% on top of what you wrote there."
For the same quantity of eligible prefix tokens, one write plus one complete reuse costs 1.35x ordinary input processing, compared with 2x for two uncached passes. At Sol's short-context rates, that is $5.40 rather than $8.00 per million prefix tokens across those two passes. A write with no later reuse costs 25% more than ordinary input processing. Unique-request workloads can therefore benefit from controlling which content gets written, a concern raised in this r/OpenAI thread:
"Most of our API usage isn't for chat bots or long-running agents. We build task-oriented applications where every request is unique: document processing, …"
The OpenAI caching guide explains that cached key-value states preserve work from an earlier prefix. They occupy resources while retained, but that mechanism alone does not prove the provider's cost or justify a particular markup. For comparison, Anthropic's pricing lists Opus 5 writes at 1.25x ordinary input for five-minute retention and 2x for one hour. Compare the retention and reuse pattern, not just the write multiplier.
The mechanics that decide whether you win the bet
From the prompt caching guide:
| Mechanic | Value |
|---|---|
| Minimum cacheable prefix, GPT-5.6 and later | 1,024 tokens, a strict minimum |
| Minimum on earlier models | 2,048 visible tokens; some earlier models may produce hits below this |
| Cache lifetime, GPT-5.6 and later | At least 30 minutes after the latest write or reuse; reuse has no new write charge |
| Cache read rate | 10% of the input rate |
| Cache write rate | 125% of the input rate |
| Matching | Exact prefix match at an eligible breakpoint |
| Routing key | Optional prompt_cache_key; stable keys help route shared prefixes, but do not guarantee reuse |
| Routing capacity | Above about 15 requests per minute on a machine, overflow routing can cause cache misses |
| Writes per request | Maximum of 4 |
| Breakpoints considered on read | The latest 50 |
For GPT-5.6 and later, explicit-only caching can place a breakpoint after stable instructions while leaving changing ticket content outside the cache write. With explicit mode and no breakpoints, the request neither reads nor writes the cache. This matters for one-off support requests: repeating the same instructions is not sufficient if the only saved breakpoint also includes a different customer's message. I would compare cached_tokens, cache_write_tokens and total input cost before and after a change.
For a busy support queue, I would watch routing as well as prefix matching. The docs explain that traffic above about 15 requests per minute on a machine can overflow elsewhere and miss its cache. This is not a guaranteed per-key limit or a promise that every request above it misses. If a busy group's cache hits decline, distribute it across stable keys, then measure the result. Keys influence routing; they do not reserve a machine.
The docs are also explicit that "repeated prompt content alone does not guarantee a cache hit." The failure modes are mundane and expensive, and Eric Nowoslawski's LinkedIn writeup is the clearest statement of them I have found, from someone who got it wrong first:
"We were messing it up with putting custom parts of the prompt in the second or third sentence."
Cache lifetime matters for scheduled work. Consider ten hypothetical requests spaced ten minutes apart, each reusing the same eligible 100,000-token prefix. At current Sol Standard short-context rates, processing that prefix uncached ten times costs $4.00. One write followed by nine complete cache reads costs $0.86: $0.50 for the write plus nine reads at $0.04 each. This excludes other input and output tokens.
The 30-minute lifetime permits reuse across those ten-minute gaps, but timing alone does not guarantee hits: matching breakpoints and routing still matter. A cache that expires before each request would change the result. I would compare the actual retention settings and observed reuse before claiming one provider is cheaper. Ravi Kiran's caching post emphasizes reuse and routing. Its numerical hit-rate claims concern other serving setups and are not a measured baseline for your OpenAI application. The practical point is:
"You need sticky routing, stable prefixes, and workloads that actually repeat."
I would use the measured fraction of input tokens served from cache in the calculator, then test lower-hit scenarios. Neither 30% nor 90% is a defensible default for every application, and the calculator's estimate still excludes cache-write charges.
Reasoning tokens bill at the output rate
All three GPT-5.6 models accept reasoning.effort at none, low, medium, high, xhigh or max, with medium as the default. Those reasoning tokens are billed as output tokens.
Reasoning effort affects token volume rather than the per-token rate. For example, Sol Standard short-context output costs $20 per million tokens, including billed reasoning tokens. A higher effort setting can increase usage, but the size of that change depends on the task. I would measure it rather than assume a fixed multiplier between effort levels.
"But at least via the API, you pay for tokens you cannot see."
The knock-on effect is that reasoning effort partly collapses the price gap the model tiers are supposed to represent. One commenter on the Qwen 3.8 Max thread framed it precisely:
"So a mid priced model, with heavy reasoning output, cost the same as a expensive model, with medium reasoning output."
When comparing reasoning settings, record the model, evaluation tasks, effort level and total billed tokens. A third-party benchmark can suggest candidates to test, but it is not a measurement of your support queue. I would compare quality and cost on the same representative requests before selecting a setting.
One developer shared a local usage analysis priced at Opus 4.7 list rates, not an OpenAI invoice. The main-thread estimate was $19,221: 56% cache reads, 35% cache writes and 8% output including reasoning. The wider analysis covered 933 sessions across main threads and subagents, with a combined estimate of about $22,720. These are the author's reconstructed costs, not verified charges paid.
"Same shape as yours: re-read dominates, reasoning is the biggest re-read line, caching is the only thing keeping it sane."
That reported estimate illustrates one possible cost distribution, not a rule for every agent. Repeatedly processing a long conversation can make cached input a large expense even with a high hit rate. Other workloads may be dominated by output, cache writes or tools. I would separate those categories in actual usage records before choosing an optimization.
I would measure token counts and answer quality at each effort level on representative traffic. Changing the service tier, shortening redundant context, improving reuse and selecting another model address different costs. Our AI models for support tickets guide discusses model selection for that workload; it is not evidence that one optimization wins across all queues.
Batch, Flex and Fast mode
For the four models in the calculator, service tiers change the published token rates as shown below. Flex and Fast use a request setting; Batch requires submitting work through the separate Batch API workflow.
| Tier | Multiplier | What you give up or get | Field value |
|---|---|---|---|
| Batch | 0.5x | 24-hour completion window, no other window offered | Batch API endpoint |
| Flex | 0.5x | Slower responses, occasional resource unavailability | service_tier: "flex" |
| Standard | 1x | Base rate | Check effective tier; omitted setting follows project default |
| Fast mode | 2x | Up to 2.5x faster, more consistent latency | service_tier: "fast" or "priority" |
A few details from the docs that change how you would use them.
The Batch API offers 50% lower token costs and a separate rate-limit pool. For Sol at Tier 5, the listed batch queue holds 15 billion input tokens; that is a queue-capacity limit, not directly comparable throughput to its 40 million tokens-per-minute synchronous cap. A batch allows up to 50,000 requests and a 200 MB input file, with up to 2,000 batch creations per hour. Its supported completion window is 24 hours. If a batch expires, unfinished requests are canceled and completed requests remain billable. This makes it suitable for work that can wait, not every live support reply. One practitioner discussed adapting the product experience to that delay:
"The other thing I started looking into is batch pricing which represents 50% off for OAI tokens right now."
Check Batch support for the exact model and endpoint before designing around it. The pricing page includes Batch rows for several Pro models, so neither the Pro label nor a high Standard price establishes that Batch is unavailable. Latency remains a separate constraint. Our Codex pricing breakdown covers that model’s costs.
Flex processing uses Batch token rates for synchronous requests on supported models. It can be slower or temporarily unavailable, so OpenAI recommends it for lower-priority work such as evaluations and enrichment. The guide shows a 15-minute timeout for lengthy requests. A Flex resource-unavailable error is not charged, but that does not mean every failed or timed-out request is free. Bound retries and decide explicitly whether falling back to the project's default tier is worth the different cost.
Fast mode was renamed from Priority processing on July 30, 2026. Both service_tier: "priority" and service_tier: "fast" are supported. OpenAI advertises up to 2.5x faster speeds for Sol, not a guaranteed latency reduction on every request. For the four calculator models, published Fast token rates are twice Standard rates; this doubles the price per token, not the number of tokens used. Fast does not support fine-tuned models or embeddings.
Check the project default as well as the request. A project configured for Fast can use it when service_tier is omitted; omission does not guarantee Standard pricing. The response's service_tier identifies the tier actually used. GPT-5.6 responses report priority for Fast, and requests downgraded during rapid traffic growth can report default and receive Standard pricing.
Two warnings on it. First, Fast mode compounds with the long-context surcharge: Sol Fast long-context input costs $16.00 per million tokens, compared with $4.00 for Standard short-context input. That is 4x, not 2x. Second, check the effective tier in your requests rather than assuming a background job uses Standard:
"When I was going through this it was because OpenAI had defaulted to /fast mode with 2x token usage"
That was someone diagnosing an unexplained burn-rate spike on the GPT-5.6 launch thread. Whether 2.5x speed is worth 2x cost is a real question with a real answer for your product. Paying it by accident on a background job is not a question at all.
Everything else that lands on the invoice
Tokens are not the whole bill. Tools, audio, images and video all carry their own meters, and this is where a "cheap" prototype quietly stops being cheap.
Tools
| Tool | Detail | Price |
|---|---|---|
| Web search | All models | $10.00 / 1k calls, plus content tokens at model rates |
| Web search preview | Non-reasoning models | $25.00 / 1k calls, content tokens free |
| File search | Tool call | $2.50 / 1k calls |
| File search | Storage | $0.10 / GB per day, 1 GB free |
| Containers | Hosted Shell and Code Interpreter | $0.03 to $1.92 per 20-min session, by memory size |
| AgentKit | ChatKit upload storage | $0.10 / GB-day after 1 GB free per month |
Web-search content tokens are retrieved material passed to the model and charged at its input rate, in addition to applicable search-call fees. Eligible container sessions are metered by the minute with a five-minute minimum; check the pricing conditions for the session rather than assuming every brief execution gets prorated billing. File-search tool-call pricing applies to the Responses API. Our AgentKit guide, vector stores API reference and Assistants API guide cover these different interfaces.
Audio, realtime and transcription
| Model | Modality | Input | Cached input | Output |
|---|---|---|---|---|
gpt-realtime-2.1 | Audio | $32.00 | $0.40 | $64.00 |
gpt-realtime-2.1 | Text | $4.00 | $0.40 | $24.00 |
gpt-realtime-2.1-mini | Audio | $10.00 | $0.30 | $20.00 |
gpt-realtime-2.1-mini | Text | $0.60 | $0.06 | $2.40 |
Audio output costs $64.00 per million tokens for gpt-realtime-2.1, versus $20.00 for its mini variant. These are audio-token rates, so comparing them directly with text-token prices does not tell you the cost of a conversation. I would measure audio usage and response quality on representative calls. Our GPT-realtime mini pricing guide discusses that tradeoff, and the audio and speech API guide covers the non-realtime path.
The pricing page provides per-minute rates or estimates for transcription. Some models also have token-based pricing, so these figures should not all be read as a flat per-minute billing contract:
| Model | Use case | Cost per minute |
|---|---|---|
gpt-realtime-translate | Live translation | $0.034 |
gpt-live-transcribe | Live transcription | $0.017 |
gpt-realtime-whisper | Live transcription | $0.017 |
gpt-transcribe | Transcription | $0.0045 |
gpt-4o-transcribe | Transcription | $0.006 |
gpt-4o-mini-transcribe | Transcription | $0.003 |
The listed $0.017 per minute for gpt-live-transcribe is about 3.8x the $0.0045 rate for gpt-transcribe. The latter rate is about 74% lower, but these are different models and workflows. This comparison is not a Batch API discount; test latency, accuracy and feature requirements before switching.
Embeddings
OpenAI publishes embeddings prices per million input tokens on its pricing page: $0.02 for text-embedding-3-small, $0.13 for text-embedding-3-large, and $0.10 for text-embedding-ada-002. The embeddings guide also gives illustrative pages-per-dollar and benchmark comparisons:
| Model | Pages per dollar | MTEB score | Max input |
|---|---|---|---|
text-embedding-3-small | 62,500 | 62.3% | 8,192 |
text-embedding-3-large | 9,615 | 64.6% | 8,192 |
The large model's token rate is 6.5x the small model's. The benchmark difference does not establish how much better it will retrieve answers from your help centre. I would test both on the same questions and documents, while also checking chunking and retrieval settings. Our notes on building an AI knowledge base cover that setup.
Images and video
gpt-image-2 bills $8.00 per 1M image input tokens, $2.00 cached, and $30.00 output, with text input at $5.00. Note that cached input here is 25% of input rather than the 10% text models get. Batch halves all of it.
The generation guide lists these GPT Image 2 output-cost estimates at selected sizes. Add text input and any reference-image input charges to estimate a complete request:
| Quality | Square 1024x1024 | Portrait 1024x1536 | Landscape 1536x1024 |
|---|---|---|---|
| Low | $0.006 | $0.005 | $0.005 |
| High | $0.211 | $0.165 | $0.165 |
At these listed output-cost estimates, a high-quality square image costs about 28% more than a high-quality landscape image despite having fewer pixels. Low to high quality on the square is about a 35x increase. Each streamed partial image adds 100 image output tokens. Our image edit API notes cover editing endpoints.
Video is per second, not per token:
| Model | Size | Standard | Batch |
|---|---|---|---|
sora-2 | 720p | $0.10 | $0.05 |
sora-2-pro | 720p | $0.30 | $0.15 |
sora-2-pro | 1024p | $0.50 | $0.25 |
sora-2-pro | 1080p | $0.70 | $0.35 |
A single minute of 1080p sora-2-pro is $42.00 on standard. Our Sora 2 breakdown covers what you get for it.
Usage tiers decide what you are allowed to spend
OpenAI's usage tiers link payment qualifications to approved monthly usage limits and model rate limits. These are distinct from the spend alerts and hard limits you configure yourself. The dollar amount in the Free row is an approved usage limit, not a grant of free credits.
| Tier | Qualification | Monthly usage limit |
|---|---|---|
| Free | Allowed geography only | $100 / month |
| Tier 1 | $5 paid | $100 / month |
| Tier 2 | $50 paid | $500 / month |
| Tier 3 | $100 paid | $1,000 / month |
| Tier 4 | $250 paid | $5,000 / month |
| Tier 5 | $1,000 paid | $200,000 / month |
And the per-model rate limits move with it. For gpt-5.6-sol:
| Tier | RPM | TPM | Batch queue limit |
|---|---|---|---|
| Tier 1 | 500 | 500,000 | 1,500,000 |
| Tier 2 | 5,000 | 1,000,000 | 3,000,000 |
| Tier 3 | 5,000 | 2,000,000 | 100,000,000 |
| Tier 4 | 10,000 | 4,000,000 | 200,000,000 |
| Tier 5 | 15,000 | 40,000,000 | 15,000,000,000 |
Sol's current model page lists Standard limits starting at Tier 1; the usage-tier guide lists $5 paid as that tier's qualification. Payment qualification is not the same as $5 of consumed tokens. Tier 5 provides 10x Tier 4's listed TPM and 75x its batch queue capacity, but it is not a universal production requirement. I would compare the application's peak demand with its actual organization and project limits.
Rate limits are set at the organisation and project level rather than per user, and some model families share a pool, so a noisy internal tool can throttle your production traffic. Vector store ingestion has its own cap of 300 requests per minute per store.
For cost control, spend alerts and hard spend limits do different jobs. An alert sends a notification while traffic continues. An enforced organization or project hard limit makes affected requests return 429 after tracked spend reaches the configured amount. Enforcement has a delay, so recorded usage can slightly exceed the cap. I would pair alerts with a deliberate hard-limit decision and an application-level fallback, because a cap can also interrupt customer support. Retrying a spend-limit error does not restore the budget.
Regional pricing, cloud billing and fine-tuning deadlines
Data residency costs 10%. The note appears under all four service-tier tables: regional processing endpoints "are charged a 10% uplift for models released on or after March 5, 2026, that are eligible for data residency." If you are in a regulated vertical and assumed EU processing was free, it is not. The your data guide lists supported regions.
Bedrock uses AWS billing. The OpenAI Bedrock guide distinguishes that route from the direct API. Prices can differ, so check the applicable AWS model and region. Bedrock's context limits are also model-specific: 272,000 tokens for GPT-5.4 and GPT-5.5, but 1,050,000 for GPT-5.6 Sol, Terra and Luna. Do not apply the older models' limit to the entire integration.
Self-serve fine-tuning also has a deadline. The deprecations page says organizations without previous fine-tuning use lost training access on May 7, 2026. On July 2, access ended for organizations without fine-tuned-model inference in the preceding 60 days. Active existing customers lose the ability to create new fine-tuning jobs on January 6, 2027. Inference continues until the underlying base model is deprecated, which may have a separate, earlier deadline. The pricing page still lists multiple fine-tuning models; a listed price does not establish that your organization can start a training job.
If your cost model depends on fine-tuning a smaller model, check both training eligibility and the base model's retirement date. Prompt caching and retrieval can address some cost or context problems, but they are not equivalent substitutes for learning specialized behavior through fine-tuning.
How OpenAI compares on price
These selected rates are in US dollars per million tokens, checked September 8, 2026. OpenAI rows use Standard short-context pricing; DeepSeek uses off-peak pricing. The table excludes tools, cache writes, storage and taxes. A flat token rate applies only within each model's supported context window, not an unlimited input length.
| Model | Input | Cached read | Output | Long-context pricing |
|---|---|---|---|---|
| GPT-5.6 Sol | $4.00 | $0.40 | $20.00 | Input 2x and output 1.5x above 272K input tokens |
| GPT-5.6 Terra | $2.00 | $0.20 | $12.00 | Same multipliers |
| GPT-5.6 Luna | $0.20 | $0.02 | $1.20 | Same multipliers |
| Claude Opus 5 | $5.00 | $0.50 | $25.00 | Flat across supported window |
| Claude Sonnet 5 | $2.00 | $0.20 | $10.00 | Flat across supported window |
| Claude Haiku 4.5 | $1.00 | $0.10 | $5.00 | Flat across supported window |
| Gemini 3.7 Flash | $0.75 | $0.075 | $3.75 | No context-band surcharge listed |
| DeepSeek V4 Flash | $0.22 | $0.007 | $0.66 | No context-band surcharge listed |
| Kimi K3 | $3.00 | $0.30 | $15.00 | No context-band surcharge listed |
Sources: OpenAI, Anthropic, Google, DeepSeek and Kimi.
Google lists Gemini 3.7 Flash's $0.75/$3.75 rates through December 31, 2026, then $1.50/$7.50 from January 1, 2027. Its Standard free tier includes free input and output, with separate limits and data-use terms. Paid context caching also has a storage charge; the cached-read rate alone is not its full cost.
DeepSeek doubles the listed off-peak rates during 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday. All other hours are off-peak. I would use the expected request schedule, not only the lowest row, when budgeting a support service that runs around the clock.
At current short-context rates, Sol's promotional $4 input and $20 output are below Opus 5's $5 and $25. Sonnet 5 matches Terra's $2 input rate and charges $10 output versus Terra's $12. These are per-million-token comparisons, not cost-per-task results: models can tokenize the same text differently and generate different amounts of reasoning. Anthropic's pricing documentation also distinguishes long-context pricing:
Claude 4.6 and later models and Claude Mythos Preview include the full 1M token context window at standard pricing. (A 900k-token request is billed at the same per-token rate as a 9k-token request.)
The context band can change which option costs less. For short prompts, the listed Gemini 3.7 Flash output rate of $3.75 is higher than Luna's $1.20, not lower. Similarly, DeepSeek's listed off-peak input rate of $0.22 is higher than Luna's $0.20, while its $0.66 output rate is lower. A single claim that one provider is cheapest hides those differences. I would compare each workload's input, cache and output quantities, then account for promotional periods and any time-of-day pricing.
My take: before planning a migration, inspect actual context lengths, service tiers and cache usage. Test Batch for work that can wait, and test shorter prompts where context is redundant. Do not remove information needed for a correct answer just to cross a pricing threshold. Compare those measured savings with another provider on the same tasks; neither the savings nor the migration effort can be inferred from a rate card alone.
Only after that is a vendor comparison worth your time, and our GPT-5.6 alternatives roundup compares the field properly. If what you are actually costing is a consumer seat rather than metered tokens, ChatGPT pricing is the equivalent breakdown.
Three worked examples
Here are three hypothetical monthly workloads using the current rates. All assume that 50% of input tokens are billed as cached input unless stated. These are token-cost estimates, not complete invoices: they exclude cache writes, tools, storage, regional processing charges and other services. Output counts must include any billed reasoning tokens.
A ticket classifier at volume. Luna, 4,000 input tokens per ticket, 300 output, 50,000 tickets a month, with 60% of input tokens billed as cached. That is $36.40 a month on Standard or $18.20 on Batch. I would test classification accuracy before choosing the cheaper model; a low token bill does not establish that its labels are useful.
A retrieval answer bot. Sol, 40,000 input tokens, 900 output, 30,000 requests a month. The estimate is $3,180 on Standard, $1,590 on Batch or $6,360 on Fast mode. The Batch-to-Fast difference is $4,770 with these token counts held constant. This calculation does not measure response quality or whether Batch latency fits a live support conversation.
The same bot after a retrieval change. Sol, 300,000 input tokens, 900 output, 30,000 requests on Standard. The estimate rises to $40,410, about 12.7x the 40,000-token Standard example. Two things changed: there are 7.5x as many input tokens, and each request now uses long-context rates. It would be misleading to attribute the entire increase to crossing the threshold.
The third case is why I keep saying the model row is not the story. And it is also why, for a support queue specifically, I think token pricing is often the wrong abstraction to be reasoning in at all.
Where token pricing stops being the right question
Everything above is a fair description of what you pay a model provider. It is a poor description of what a support ticket costs you.
A support ticket can require several model requests, retrieval steps and helpdesk actions. Model-generated tool arguments and returned tool results can add billed tokens; executing a helpdesk API call does not inherently create another model-token charge. Count the actual model requests, billable tool services and infrastructure costs. Recheck the estimate when the workflow changes.
One r/SaaS poster reported a costly loop while also exploring demand for a tool to prevent it. This is a self-reported incident, not an independently audited invoice:
"Hey everyone, I just got hit with a $4,200 OpenAI bill because an agent I deployed for customer support got stuck in a recursive loop with my CRM tool call."
The post describes a runaway loop, but does not establish which spend controls were configured. That risk calls for bounded retries, limits on repeated tool calls, monitoring and deliberate spend controls. OpenAI supports enforced hard limits, with a propagation delay; token billing does not inherently mean a bill without a ceiling.
Subscriptions and API usage have different pricing terms. In a Hacker News comment, Simon Willison reported paying $200 for subscriptions and estimated the API-equivalent cost of that usage:
"the API cost version of my token spend was $2,100"
The reported API-equivalent estimate is 10.5x the subscription payment, but this is not a controlled comparison of interchangeable products. Subscription allowances and direct API billing use different terms. For an API deployment, estimate the requests it will actually make rather than converting a subscription price into a token budget.
A March 2026 sales note records a multi-company e-commerce operator scaling toward 150,000 tickets a month who found per-interaction and per-ticket pricing confusing. The buyer projected about $30,000 monthly using the rate discussed then. That historical estimate is not current eesel pricing. It illustrates why I would define the billing unit and expected workload before comparing offers.
A managed service changes which parts of the workflow you operate and how usage is charged. Our AI customer support cost savings guide examines that build-versus-buy question.
If you are earlier than that and still sizing the category rather than the bill, our AI ticketing system guide is the better starting point.
Inspect support usage through eesel CLI
API pricing tells you what a model provider charges your application. With eesel, you operate a managed teammate and pay under eesel's task-based terms. The eesel CLI is another way to access the same teammate and workspace as the dashboard, not a separate model subscription or a way to avoid usage charges.
That is useful when a coding agent is helping investigate a cost question. Claude Code, Cursor, or Codex can read the CLI's JSON output and help inspect billing, recent activity, and the automations that start work. You are asking it to examine an existing support setup, not to build another application or infer your invoice from an OpenAI token rate.
For an existing workspace, start with authentication and destination checks. These commands require Node.js 18.17 or newer:
npx @eesel/cli login
npx @eesel/cli whoami
npx @eesel/cli agents
npx @eesel/cli billing
Then select the intended teammate explicitly. Replace SUPPORT_AGENT_ID with its identifier:
npx @eesel/cli status --agent SUPPORT_AGENT_ID
npx @eesel/cli activity --agent SUPPORT_AGENT_ID
npx @eesel/cli automations --agent SUPPORT_AGENT_ID
Billing is a read-only view of current billing state. Do not assume that selecting one teammate narrows every workspace-level charge to that teammate. Compare the scope and dates in the returned records. Activity can help explain what ran; it does not prove every task succeeded, and an activity total is not automatically the invoice total.
A bounded instruction for the coding agent could be:
Inspect billing, recent activity, and the selected teammate's automations. Explain which work starts automatically and identify any missing information needed to estimate costs. Do not change spend limits, payment details, integrations, or automations. Propose any changes for review, and do not expose credentials.
The current pricing documentation lists regular support tickets and chat sessions at $0.40 each and heavy blog tasks at $4.00 per run. Pay-as-you-go has no platform fee; Enterprise adds a platform fee on top of usage. Tasks are billed regardless of outcome. The CLI documentation specifically treats chats as billed work, so do not assume that free configuration inspection means free CLI rehearsals.
For a hypothetical month containing only 1,000 regular support tasks, the usage component is $400 at the listed rate. That example excludes other task types, plan charges, commitment terms, and any work outside those 1,000 tasks. Use the actual workspace terms to calculate the bill instead of treating the example as a universal flat fee.
Test the rollout decision, not just the arithmetic
Suppose activity increased after an automation was widened to more support topics. First inspect the trigger and filters. A volume increase is a reason to investigate, not proof of duplicate billing or of a malfunction. Ask whether the additional tasks were intended and whether their answers met policy.
For a fictional rehearsal, disable write actions and use an approved cancellation policy. Ask the teammate to draft a response to a customer who wants a subscription canceled but also wants access retained beyond the normal end date. It should separate the policy from the requested exception, identify when human approval is needed, and avoid claiming the subscription was changed.
Use a fresh conversation with new --name, scoped to the selected agent, when starting this case. Follow-up chat continues that conversation. Include billed CLI chats in your test budget. The --dry-run flag previews a write request, not answer quality or future spend.
If you approve changing the live automation afterward, verify both sides: the intended requests reach the teammate, and excluded requests do not. Review the actual customer-facing result separately from the activity count. Restricting volume can control costs, but it does not by itself improve the answer.
Try eesel
For a support queue, compare the cost of the complete workflow rather than a model call alone. eesel uses task-based pricing, and the CLI lets you inspect workspace billing and the selected teammate's activity without building a separate support application. Check the current plan, task mix, and trial terms before estimating a monthly total.
Start with a defined set of requests and inspect the automation that selects them. Rehearse policy answers before enabling writes, then verify actual action delivery. A report showing task volume is evidence of activity, not proof of successful resolution or an exact invoice forecast.
If you need application-specific model orchestration or infrastructure, compare a custom API implementation with the supported workflow of a managed teammate. Different billing units reflect different responsibilities; neither pricing model guarantees the better result for your task.
Confirm the supported integrations, knowledge readiness, and action permissions for the workflow you plan to run. Connecting a source is not proof that its content has finished downloading or that every helpdesk action is available.
Before deciding, compare the same workload with your helpdesk's native AI offering and include testing and operating costs on each side.
Try eesel if you want to configure a support teammate and inspect its operation through the CLI. Review the current terms and proposed permissions, then expand only after checking the results.
Frequently Asked Questions
How much does the OpenAI API cost per 1M tokens in 2026?
What is the cheapest way to use the OpenAI API?
Is there a free tier for the OpenAI API?
Why is my OpenAI API bill higher than the pricing page suggested?
reasoning_effort is producing far more output tokens than you counted. Tool calls also bill separately on top of tokens. Our guide to OpenAI rate limits covers the related throughput caps.How does OpenAI API pricing compare to Claude and Gemini?
What does OpenAI charge for tools like web search and file search?
How much does AI customer support cost if I do not want to manage tokens?
Article by
Rama Adi Nugraha
Rama is a software engineer at eesel AI with two years of experience writing about B2B SaaS, AI tools, and customer support technology. Based in Bali, Indonesia, he brings a developer's perspective to product comparisons — cutting through marketing copy to what the integrations and APIs actually do.
