
OpenAI API pricing starts with input and output tokens, but those two numbers do not describe the full bill. Prompt caching can create cache-write and cache-read charges, requests above the long-context threshold use higher rates, processing speed changes the token price, and hosted tools add call or storage fees.
A useful estimate therefore needs more than the model name. It needs the model ID, prompt length, service tier, cache behavior, reasoning-token usage, tool calls, retries, and percentage of attempts that produce an accepted result.
This guide explains current first-party OpenAI API rates, calculates three example workloads, and includes a standalone Python calculator for estimating text-model costs before deployment.
Quick Answer
For prompts with 272,000 or fewer input tokens, standard OpenAI API rates for the main GPT-6 family currently range from $0.10 per million input tokens and $0.50 per million output tokens for GPT-6 Luna to $10 per million input tokens and $50 per million output tokens for GPT-6 Astra. GPT-6.1 Terra costs $1 per million input tokens and $5 per million output tokens, while GPT-6.1 Sol costs $2 and $10.
Those are standard, short-context text-token rates before cache writes, cache reads, processing-tier adjustments, regional-processing uplifts, hosted-tool charges, storage, tax, or negotiated terms. If a prompt exceeds 272,000 input tokens, OpenAI currently prices the full request at 2x the short-context input and cache rates and 1.5x the short-context output rate.
Key Takeaways
- OpenAI bills input and output separately. At Standard short-context rates, output costs 5x input for the four main GPT-6 models, and internal reasoning tokens are billed as output.
- Prompt caching has three input categories. Ordinary input, cache writes, and cache reads use different prices. For GPT-5.6 and later, a 30-minute write normally costs 1.25x the base input rate, while a 12-hour write costs 2.5x.
- Long prompts can change the rate for the entire request. Above 272,000 input tokens, the main current models use 2x input and cache rates and 1.5x output rates.
- Batch and Flex are currently 50% below Standard token rates. Batch is asynchronous with a 24-hour completion window. Flex serves lower-priority requests with slower responses and possible resource-unavailable errors.
- Lower latency costs more. Fast pricing is currently 2x Standard for the main models. Ultrafast is 6x Standard and is listed for GPT-6 Astra and GPT-6.1 Sol.
- Hosted tools add separate costs. Web search, file search, containers, and storage can add fees on top of model tokens.
- ChatGPT and API billing are separate. Eligible Pro and Business subscribers can currently claim defined API-credit benefits, but a ChatGPT subscription does not make API usage unlimited.
- Cost per accepted result matters more than cost per attempted call. Invalid outputs, retries, tool loops, and failed validation increase the bill required to produce usable results.
Methodology and disclosure: Prices and rules were checked against OpenAI's official API pricing documentation, model pages, prompt-caching guide, and billing documentation on November 16, 2026. The examples below are calculations based on stated assumptions, not observations from a private OpenAI invoice. The Python calculator was syntax-checked and run locally but does not call the API or retrieve live prices. Verify the current documentation and your account terms before budgeting production usage.
OpenAI API Pricing at a Glance
The following table covers the main current GPT-6 models at Standard speed for prompts with no more than 272,000 input tokens. Prices are in USD per one million tokens.
| OpenAI model | Input | Output | Cached input | 30-minute cache write | 12-hour cache write | General positioning |
|---|---|---|---|---|---|---|
| GPT-6 Luna (`gpt-6-luna`) | $0.10 | $0.50 | $0.01 | $0.125 | $0.25 | Focused, high-volume tasks where cost and latency matter |
| GPT-6.1 Terra (`gpt-6.1-terra`) | $1 | $5 | $0.05 | $1.25 | $2.50 | Visual reasoning, computer use, and writing |
| GPT-6.1 Sol (`gpt-6.1-sol`) | $2 | $10 | $0.10 | $2.50 | $5 | Complex coding and professional work at a lower cost than Astra |
| GPT-6 Astra (`gpt-6-astra`) | $10 | $50 | $1 | $12.50 | $25 | The most demanding reasoning, coding, research, and document work |
Source: OpenAI API pricing and the current OpenAI model catalog. Prices were checked on November 16, 2026.
The lowest token rate is not automatically the lowest application cost. A cheaper model that fails a schema, misses facts, or needs repeated calls can cost more per accepted result than a stronger model that succeeds on the first attempt. Model selection should start with a representative evaluation set, not the rate table alone.
What Counts as an Input or Output Token?
Input tokens can include:
- developer and user messages;
- conversation history;
- tool names, descriptions, and schemas;
- tool results returned to the model;
- retrieved documents and file content;
- image input, according to the selected model's image-token rules;
- formatting used to represent the complete request; and
- prompt tokens written to or read from cache.
Output usage can include visible answer text, function or tool-call structure, internal formatting, and reasoning tokens. OpenAI's reasoning guide says reasoning tokens are not exposed as raw text, but they still occupy context and are billed at the output-token rate. A 200-token visible answer can therefore have substantially more than 200 billable output tokens.
Tokens are not a fixed conversion from words or characters. The exact count depends on the model, encoding, language, request structure, tools, images, and files. OpenAI provides a Responses input-token counting endpoint for complete inputs; use recorded response usage for the final output count.
How to Calculate OpenAI API Cost
For a basic Standard request with short context, no caching, and no tools, use:
For a fuller estimate, keep the input categories separate:
Then apply only the modifiers that actually match the request and add non-token charges:
Do not apply every multiplier blindly. Model, endpoint, service-tier, tool, and regional support vary. Tool charges are not automatically reduced just because model tokens use Batch or Flex pricing.
Example: One GPT-6.1 Sol Request
Assume one Standard request uses:
- 5,000 ordinary input tokens;
- 1,000 output tokens, including any reasoning tokens;
- a prompt below the long-context threshold; and
- no tools, cache writes, or cache reads.
The calculation is:
At 10,000 identical successful requests, the simplified workload costs $200. If only 90% of attempts produce an accepted result and failed attempts consume the same average tokens, producing 10,000 accepted results requires about 11,111 attempts and costs approximately $222.22 before tools or storage.
Is OpenAI API Usage Included With ChatGPT?
ChatGPT and the OpenAI API use separate billing systems. A ChatGPT plan controls access and limits in ChatGPT, while API requests are metered to an API organization. OpenAI currently offers a claimable API-credit benefit to eligible paid Pro and Business subscriptions, but eligibility and activation conditions apply.
| Eligible ChatGPT subscription | Current full-period API-credit allowance |
|---|---|
| Pro, $100 tier | $100 per monthly billing period |
| Pro, $200 tier | $200 per monthly billing period |
| Pro, $500 tier | $500 per monthly billing period |
| Business Standard | $20 per paid Standard seat |
| Business Premium | $100 per paid Premium seat |
| Business workspace | Pooled contributions capped at $500 per monthly billing period |
Source: OpenAI's API credits benefit documentation, checked November 16, 2026.
The current rules say an eligible subscription must normally be active for at least seven days before claiming. The subscription or workspace owner must link one API organization, first-period grants may be prorated, and unused monthly credits do not roll over. Annually prepaid Business workspaces currently receive the year's grant at once, capped at $6,000 per annual cycle. Availability can also depend on the enabled cohort and country.
Free, Go, Plus, free-trial, Enterprise, Edu, and legacy Codex seats are not currently listed as established eligible plans for this benefit. Check the live billing interface instead of assuming that a plan name guarantees a grant. The benefit can change, and a credit balance does not remove model-access, request-rate, token-rate, project, or organization limits.
How Prompt Caching Changes OpenAI API Pricing
Prompt caching reuses work when requests begin with the same stable prefix. Examples include a long developer message, tool definitions, policies, reference material, few-shot examples, or an unchanged conversation prefix.
For GPT-5.6 and later, OpenAI currently documents:
| Cache operation | General pricing rule | Current lifetime behavior |
|---|---|---|
| Ordinary uncached input | 1x base input rate | Processed normally |
| 30-minute cache write | 1.25x base input rate | Default minimum lifetime for supported current models |
| 12-hour cache write | 2.5x base input rate | Available through supported Responses API cache options |
| Cache read | Model-specific discounted input rate | A matching valid prefix is reused |
These write prices are total rates for those tokens, not surcharges added to ordinary input. A token should be priced as ordinary input, a cache write, or a cache read according to the returned usage details; do not count it in more than one input category.
The current short-context cache rates for the main models are:
| Model | 30-minute write per 1M tokens | 12-hour write per 1M tokens | Cache read per 1M tokens |
|---|---|---|---|
| GPT-6 Luna | $0.125 | $0.25 | $0.01 |
| GPT-6.1 Terra | $1.25 | $2.50 | $0.05 |
| GPT-6.1 Sol | $2.50 | $5 | $0.10 |
| GPT-6 Astra | $12.50 | $25 | $1 |
Caching is enabled by default for supported models. For GPT-5.6 and later, a visible prompt prefix must currently reach at least 1,024 tokens before it is cacheable. Reuse requires a matching prefix; changing early instructions, tool definitions, schemas, or other cache-affecting settings can turn an expected read into a new write or ordinary input.
Calculated Example: Cached Support Instructions
Assume 20,000 support-drafting requests use GPT-6.1 Sol. Each request has:
- 8,000 repeated policy, product, and style tokens;
- 1,000 unique ticket tokens; and
- 600 output tokens, including any reasoning.
Without caching:
For the cached calculation, assume an explicit breakpoint follows the stable 8,000-token prefix and the work runs in 20 sufficiently active bursts. Each burst produces one 30-minute write and 999 cache reads. That creates 20 writes and 19,980 reads:
Under those assumptions, caching reduces the calculated total by $303.616, or approximately 63.3%. That is not a guaranteed saving. Different request timing, prefix changes, overflow routing, misses, and 12-hour writes change the result. Monitor cached_tokens, cache-write token fields, and realized cost rather than treating caching as a binary setting.
How Batch and Flex Processing Change OpenAI API Cost
OpenAI's Batch API currently provides 50% lower token costs than Standard processing, a separate pool of higher rate limits, and a 24-hour completion window. It fits asynchronous work such as:
- evaluation runs;
- dataset classification;
- document extraction;
- embeddings;
- enrichment;
- image-generation jobs; and
- other work that does not require an immediate response.
For the main models with short context, current Batch rates are:
| OpenAI model | Batch input per 1M tokens | Batch output per 1M tokens | Batch cached input per 1M tokens |
|---|---|---|---|
| GPT-6 Luna | $0.05 | $0.25 | $0.005 |
| GPT-6.1 Terra | $0.50 | $2.50 | $0.025 |
| GPT-6.1 Sol | $1 | $5 | $0.05 |
| GPT-6 Astra | $5 | $25 | $0.50 |
Flex processing uses the same listed token rates as Batch without requiring a batch file. The tradeoff is slower response time and occasional resource unavailability. OpenAI says a Flex request that fails with the documented resource-unavailable condition is not charged, but applications still need bounded retries and longer timeouts.
Batch and Flex serve different workflows. Batch groups asynchronous requests and returns results later. Flex remains a request path for lower-priority work. Neither should be treated as a drop-in latency choice for every customer-facing application.
Long-Context Pricing Above 272,000 Input Tokens
The current flagship models support context windows larger than 272,000 tokens, but the short-context price does not apply indefinitely. When a prompt contains more than 272,000 input tokens, OpenAI currently applies:
- 2x input rates;
- 2x cache-read and cache-write rates; and
- 1.5x output rates.
The adjustment applies to the full request, not only the tokens above the threshold. At Standard speed, the resulting headline rates are:
| OpenAI model | Long-context input per 1M | Long-context output per 1M | Long-context cached input per 1M |
|---|---|---|---|
| GPT-6 Luna | $0.20 | $0.75 | $0.02 |
| GPT-6.1 Terra | $2 | $7.50 | $0.10 |
| GPT-6.1 Sol | $4 | $15 | $0.20 |
| GPT-6 Astra | $20 | $75 | $2 |
This creates a cost cliff. A request with 272,001 input tokens can cost materially more than one with 272,000, even before considering the additional token. Keep only relevant context, summarize or compact long histories where appropriate, and test retrieval against sending an entire corpus on every call.
Standard, Fast, Ultrafast, and Regional Processing
OpenAI currently lists several processing choices for the main models:
| Processing choice | Current token-price relationship | Operational fit |
|---|---|---|
| Standard | 1x | Default production path |
| Batch | 0.5x | Asynchronous jobs that can complete within 24 hours |
| Flex | 0.5x | Lower-priority work that tolerates slower responses and resource unavailability |
| Fast | 2x | User-facing workloads where lower and more consistent latency justifies the premium |
| Ultrafast | 6x | Highest-speed path currently listed for GPT-6 Astra and GPT-6.1 Sol |
These relationships make budgeting easier, but availability still depends on model, endpoint, account, region, and feature. Inspect the service_tier returned by the API rather than assuming every request ran on the requested path.
OpenAI currently adds a 10% uplift for eligible data-residency endpoints when using models released on or after March 5, 2026. Regional storage and regional processing are not the same guarantee, and model, tool, and service-tier support varies by region. Use the data-residency support table for the exact project and endpoint before applying the multiplier to a budget.
Other Charges That Can Affect an OpenAI Workload
Web Search
The current non-preview web-search tool, including image search, costs $10 per 1,000 calls, or $0.01 per call, plus search-content tokens billed at the selected model's token rates. One model response can perform more than one search, so count actual tool calls rather than assuming one API request equals one search.
OpenAI also lists preview search variants with different treatment. The reasoning-model preview currently uses the same $10-per-1,000 call price plus search-content tokens. The other-model preview is listed at $25 per 1,000 calls with search-content tokens included. Use the exact tool variant shown in the request when reconciling costs.
File Search
OpenAI currently lists file-search charges of:
- $0.10 per GB per day for storage, with the first 1 GB free; and
- $2.50 per 1,000 Responses API file-search tool calls.
Model tokens used to process retrieved content are still billed at the chosen model's rates. Large chunks, too many retrieved results, or repeated retrieval in an agent loop can therefore cost more in tokens than the fixed tool-call fee.
Hosted Shell and Code Interpreter Containers
Current listed container reference prices are $0.03 for 1 GB, $0.12 for 4 GB, $0.48 for 16 GB, and $1.92 for 64 GB per 20-minute session per container. The pricing page also notes that eligible container sessions are billed by the minute with a five-minute minimum. Check the current product-specific billing behavior before turning those reference amounts into a workload formula.
Tool Definitions, Results, and Agent Turns
Function definitions, built-in-tool instructions, tool calls, and returned results can all contribute tokens. In a multi-turn agent, material from earlier turns may be sent again or reused through cache. A short final answer does not show how much context, reasoning, or tool data the application processed to reach it.
Set limits for tool calls, reasoning effort, response length, retries, and total turns. Record stop reasons and usage from every attempt, including attempts that do not produce an accepted result.
Image, Audio, Embedding, and Moderation APIs
OpenAI uses different units and modality-specific rates outside the main text models. A few current examples are:
| API category | Current example rate |
|---|---|
| GPT Image 2.6 Sunburst or Flare, image tokens | $8 input, $30 output, and $2 cached input per 1M tokens at Standard speed |
| GPT-Live-1 | $0.05 per minute for the voice session; backend model and tool usage is separate |
| GPT Realtime 2.1, audio tokens | $32 input, $64 output, and $0.40 cached input per 1M tokens |
| GPT Realtime 2.1 Mini, audio tokens | $10 input, $20 output, and $0.30 cached input per 1M tokens |
| GPT Transcribe | Estimated $0.0045 per minute |
| Text Embedding 3 Small | $0.02 per 1M input tokens |
| Text Embedding 3 Large | $0.13 per 1M input tokens |
| Omni Moderation Latest | Free |
Image cost also depends on image size, quality, and the number of generated image tokens. Audio and Realtime workloads may combine audio, text, image, session, backend-model, and tool charges. Use the relevant first-party calculator or modality table instead of applying a text-model formula to every API.
Fine-Tuning and Cloud Platforms
OpenAI's current pricing page says self-serve fine-tuning is closed to new users. Existing users have temporary continued access, and fine-tuned models remain available until their base models are deprecated. Do not build a new-project budget from the legacy fine-tuning table without confirming account eligibility and the deprecation timeline.
OpenAI models offered through Amazon Bedrock or Microsoft Azure are billed by those platforms. The first-party OpenAI API rate is not evidence of the exact partner-platform price, region, discount, or invoice terms.
Calculated Workload 1: Structured Extraction
Assume a team needs 100,000 accepted document extractions. Each attempt uses:
- 2,500 ordinary input tokens;
- 150 output tokens, including any reasoning;
- no cache;
- no tools;
- short context;
- global processing; and
- a 100% valid-result rate.
The calculated Standard and Batch token totals are:
| Model | Standard token cost | Batch token cost |
|---|---|---|
| GPT-6 Luna | $32.50 | $16.25 |
| GPT-6.1 Terra | $325 | $162.50 |
| GPT-6.1 Sol | $650 | $325 |
| GPT-6 Astra | $3,250 | $1,625 |
These values do not establish which model should be used. Evaluate representative documents and define an acceptance rule. If Luna creates invalid fields that require repeated calls or manual correction, its true cost includes those failures and review time.
Calculated Workload 2: Support Drafting With Caching
Using the 20,000-ticket assumptions above, GPT-6.1 Sol costs:
| Configuration | Calculated monthly token cost |
|---|---|
| Repeated 8,000-token prefix processed without caching | $480.00 |
| Twenty 30-minute writes and 19,980 cache reads | $176.384 |
This example shows why request timing and prefix stability matter. If the cache is missed or rewritten more often than assumed, the workload creates more expensive writes and fewer discounted reads.
Calculated Workload 3: Web-Research Agent
Assume a research workflow must produce 10,000 accepted results using GPT-6.1 Sol. Each attempt averages:
- 5,000 ordinary input tokens;
- 1,000 output tokens, including reasoning;
- one non-preview OpenAI web-search call;
- no cache;
- Standard global processing; and
- a 90% valid-result rate.
Producing 10,000 accepted results at a 90% valid-result rate requires approximately 11,111 attempts.
| Cost component | Calculation | Calculated cost |
|---|---|---|
| Input | 11,111.11 x 5,000 / 1M x $2 | $111.11 |
| Output | 11,111.11 x 1,000 / 1M x $10 | $111.11 |
| Web search | 11,111.11 x $0.01 | $111.11 |
| Total | Sum of listed components | $333.33 |
| Cost per accepted result | $333.33 / 10,000 | Approximately $0.0333 |
The failed-attempt assumption is deliberately visible. If invalid attempts stop before calling search or use fewer tokens, the real total can be lower. If the agent loops through several searches before failing, it can be higher.
Python OpenAI API Cost Calculator
The script below uses only Python's standard library. It was compiled and run with Python 3.11.2. It does not send an API request, read an OpenAI account, include taxes, or retrieve live prices. It calculates from hard-coded public rates checked on November 16, 2026.
Inputs are averages per attempt except --billable-file-storage-gb-days, which is a workload total. The success rate is:
For example, enter a 90% valid-result rate as 0.90. The calculator assumes failed attempts consume the same average tokens and tool calls as successful attempts. Split a workload into separate runs if that assumption is not appropriate.
Save the complete script as openai_api_cost.py:
Run the Web-Research Example
The tested output is:
What the Calculator Includes
The script supports:
- current Standard rates for GPT-6 Luna, GPT-6.1 Terra, GPT-6.1 Sol, and GPT-6 Astra;
- ordinary input and output, including reasoning tokens entered as output;
- 30-minute cache writes, 12-hour cache writes, and cached-input reads;
- automatic long-context pricing when total entered prompt tokens exceed 272,000 per attempt;
- validation against the main models' current 922,000-token maximum input and 128,000-token maximum output;
- Standard, Batch, Flex, Fast, and supported Ultrafast tier multipliers;
- the 10% regional-processing uplift;
- non-preview web-search call fees;
- file-search call fees;
- billable file-search GB-days entered after the free allowance; and
- a valid-result rate for calculating expected attempts and cost per accepted result.
It rejects Ultrafast pricing for models other than GPT-6 Astra and GPT-6.1 Sol, which are the models currently listed for that tier.
What the Calculator Does Not Include
The script does not include:
- taxes;
- negotiated volume or enterprise discounts;
- account-specific credits;
- Scale Tier or reserved-capacity terms;
- partner-cloud pricing;
- image, audio, Realtime, video, embedding, or fine-tuning costs;
- container charges;
- Agent Kit storage;
- alternate web-search preview pricing;
- different usage on successful and failed attempts;
- automatic checks for endpoint, region, or feature compatibility; or
- live price retrieval.
Update the RATES, TIER_MULTIPLIERS, context threshold, and fixed feature prices whenever OpenAI changes its documentation.
How to Reduce OpenAI API Costs
Start With the Cheapest Model That Passes
Build a representative evaluation set and define what an accepted result requires. Start with the least expensive model that might meet the standard, then move tasks to a stronger model only when evaluation evidence supports the added cost.
Price the accepted result rather than the attempted call:
This exposes the cost of retries, invalid structured output, missing fields, unsupported claims, and manual review.
Control Reasoning and Output
Reasoning tokens use the output rate even though they are not shown as answer text. Choose reasoning effort deliberately, set a sensible max_output_tokens, request only the fields or length the application needs, and stop agent loops after a bounded number of turns.
Keep Prompts Below the Long-Context Threshold When Practical
More than 272,000 input tokens currently triggers higher rates for the full request. Retrieve relevant chunks, compact conversation history, remove repeated tool output, and avoid sending an entire corpus when a smaller evidence set is sufficient.
Design Stable Cache Prefixes
Put reusable instructions, examples, reference material, and tool definitions before request-specific content. Monitor cache writes and reads separately. A cache setting does not prove that a later request matched the expected prefix.
Use Batch or Flex for Work That Can Wait
Batch is appropriate for grouped asynchronous jobs with a 24-hour window. Flex can reduce synchronous request cost for lower-priority workloads that tolerate slower responses and occasional resource unavailability. Keep latency-sensitive work on an appropriate Standard, Fast, or Ultrafast path.
Limit Retrieved Content and Tool Calls
Set bounds on search calls, file-search results, tool-output size, retries, and total turns. Trim irrelevant HTML or document sections before adding them to context. A poorly bounded agent can spend more on repeated tools and growing context than on its final answer.
Track Cost Components Separately
At minimum, store:
- exact model ID;
- service tier returned by the API;
- ordinary input tokens;
- cache-write tokens by lifetime;
- cached-input tokens;
- output tokens and reasoning-token details;
- prompt length and whether long-context pricing applied;
- hosted-tool calls;
- storage or container usage;
- accepted or rejected result;
- retry count; and
- task, project, or customer identifier.
That makes a higher bill diagnosable without unnecessarily logging secret or private prompt content.
Where Proxies Fit in an OpenAI-Powered Data Pipeline
OpenAI and Proxidize solve different layers. OpenAI provides model inference and hosted AI tools. Proxidize provides the network route and exit IP for an independently operated scraper or browser.
| Architecture | Main cost components | Is a separate proxy inherently required? |
|---|---|---|
| OpenAI model with OpenAI-hosted web search | Model tokens plus OpenAI search calls and search-content tokens | No |
| OpenAI model analyzing internal files or application data | Model tokens, applicable file-search or storage charges, and application infrastructure | No |
| An independently operated browser or scraper sending permitted public data to OpenAI | Collector compute, proxy traffic where needed, parsing, storage, retries, and OpenAI tokens | Sometimes |
| Location-specific public-web observations collected by your own system | Collector, suitable location routing, validation, storage, and OpenAI tokens | Often useful when the task requires that network location |
A proxy does not reduce OpenAI's token price or route an OpenAI-hosted search through a customer-selected exit. It becomes relevant when a team operates its own authorized collector and needs broad geographic routing, location-specific observations, or more control over the network layer.
Proxidize Residential Proxies provide global residential routing across supported countries, cities, and ISPs. Proxidize Mobile Proxies are the stronger fit when the observation specifically requires a supported mobile-network context or city- and ASN/ISP-level targeting.
The collector still owns navigation, extraction, validation, scheduling, reasonable rate control, storage, and compliance. Customers are responsible for ensuring that web collection and automated access comply with applicable laws and third-party terms.
For the implementation path, see How to Use Residential Proxies With the OpenAI Agents SDK. For broader architecture and product selection, see How AI Agents Access the Web and Best Proxies for AI Agents.
Final Verdict
OpenAI API cost is not one number. The selected model establishes base rates, but prompt length, cache writes and reads, reasoning tokens, processing tier, region, tools, retries, and success rate determine what the application actually spends.
Start with representative tasks, record real usage, and calculate cost per accepted result. Use caching for stable repeated prefixes, Batch or Flex for eligible work that can wait, and strict limits for output, tools, retries, and agent turns. Recheck OpenAI's live pricing and model documentation before every production budget or model migration.
If an OpenAI application analyzes data collected through an independently operated web pipeline, calculate collection and inference separately. Proxies can support the network layer when a lawful workflow needs them; they do not replace the collector or change OpenAI's token prices.
Sources
- OpenAI API pricing
- OpenAI model catalog
- GPT-6 Astra model pricing and limits
- GPT-6.1 Sol model pricing and limits
- GPT-6.1 Terra model pricing and limits
- GPT-6 Luna model pricing and limits
- OpenAI prompt caching
- OpenAI Batch API
- OpenAI Flex processing
- OpenAI Fast mode
- OpenAI Ultrafast mode
- OpenAI data residency
- OpenAI reasoning models
- OpenAI and ChatGPT billing separation
- API credits for eligible ChatGPT subscriptions
- OpenAI prepaid API billing
Frequently asked questions
OpenAI primarily charges flagship text models by input, output, cache-write, and cached-input tokens. For short-context Standard requests, the main current models range from $0.10 per million input tokens and $0.50 per million output tokens for GPT-6 Luna to $10 and $50 for GPT-6 Astra. Long context, processing tier, regional endpoints, tools, storage, retries, and reasoning tokens can change the total.
It depends on the exact model and token category. GPT-6.1 Terra currently costs $1 per million Standard short-context input tokens and $5 per million output tokens. GPT-6.1 Sol costs $2 and $10. GPT-6 Luna and GPT-6 Astra use different rates. Always identify whether a figure refers to ordinary input, output, a cache write, cached input, long context, or a different service tier.
Divide the per-million rate by 1,000. At current Standard short-context rates, 1,000 GPT-6.1 Sol input tokens cost $0.002 and 1,000 output tokens cost $0.01. The equivalent input and output amounts are $0.0001 and $0.0005 for GPT-6 Luna, $0.001 and $0.005 for GPT-6.1 Terra, and $0.01 and $0.05 for GPT-6 Astra. Cache, long-context, tier, regional, and tool charges can change the request total.
“ChatGPT API” is a common search phrase, but OpenAI calls the developer product the OpenAI API. Developers use endpoints such as Responses and Chat Completions with available OpenAI models. ChatGPT is the end-user application and subscription product; its billing is separate from API Platform billing.
Plus is not currently listed as eligible for the API-credit benefit. Eligible paid Pro tiers and Business seats can claim defined API credits after meeting current activation requirements. Those grants fund one linked API organization, expire under the documented terms, and do not turn API use into an unlimited subscription.
OpenAI documentation may show a Free usage tier or an initial test request, but a usage tier is a limit category, not a promise of permanent production credit. Some eligible ChatGPT subscriptions can claim promotional API credits. Check the credit-grants page for the specific API organization instead of assuming that every new account receives the same balance.
Common causes include output and reasoning tokens, cache writes, a prompt above 272,000 input tokens, Fast or Ultrafast processing, regional-processing uplift, web or file-search calls, retrieved content, container or storage charges, repeated conversation context, retries, and rejected results. Reconcile the recorded usage and tool counts instead of estimating from the visible user message.
No. Cache writes cost more than ordinary input on the main current models. Savings require enough later reads of the same eligible prefix while the entry remains useful. Unstable prefixes, sparse requests, or cache misses can create writes without the expected discounted reuse.
Current listed Batch and Flex token rates for the main models are 50% below Standard. Batch is designed for asynchronous groups of requests with a 24-hour completion window. Flex keeps a request interface but trades speed and resource availability for the lower rate. Confirm model and endpoint support before budgeting either one.
The current non-preview web-search tool costs $10 per 1,000 calls, or $0.01 per call, plus search-content tokens at the chosen model's rates. Preview variants have different documented treatment. One response can perform multiple searches, so use actual call counts.
Yes. For the main current GPT-6 models, prompts above 272,000 input tokens use 2x input and cache rates and 1.5x output rates for the full request. The exact threshold and multiplier are model-specific facts that should be rechecked before a production migration.
It can. Models accessed through Microsoft Azure or Amazon Bedrock are billed by those platforms. Use the price sheet for the exact provider, model, region, service tier, and account agreement that will issue the invoice.
No. A proxy changes the network route used by an independently operated collector. It does not lower OpenAI's per-token rates or alter the route of an OpenAI-hosted tool. Proxy traffic is a separate cost when a team runs its own authorized scraper or browser and sends the resulting data to OpenAI.