Skip to main content
Pricing

Published Nov 16, 2026

OpenAI API Pricing in 2026: GPT Cost per Million Tokens

Compare OpenAI API input, output, cache, batch, speed, tools, and long-context costs. Use worked examples and Python to estimate monthly spend.

OpenAI API Pricing in 2026: GPT Cost per Million Tokens

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 modelInputOutputCached input30-minute cache write12-hour cache writeGeneral positioning
GPT-6 Luna (`gpt-6-luna`)$0.10$0.50$0.01$0.125$0.25Focused, high-volume tasks where cost and latency matter
GPT-6.1 Terra (`gpt-6.1-terra`)$1$5$0.05$1.25$2.50Visual reasoning, computer use, and writing
GPT-6.1 Sol (`gpt-6.1-sol`)$2$10$0.10$2.50$5Complex coding and professional work at a lower cost than Astra
GPT-6 Astra (`gpt-6-astra`)$10$50$1$12.50$25The 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:

bash

For a fuller estimate, keep the input categories separate:

bash

Then apply only the modifiers that actually match the request and add non-token charges:

bash

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:

bash

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 subscriptionCurrent 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 workspacePooled 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 operationGeneral pricing ruleCurrent lifetime behavior
Ordinary uncached input1x base input rateProcessed normally
30-minute cache write1.25x base input rateDefault minimum lifetime for supported current models
12-hour cache write2.5x base input rateAvailable through supported Responses API cache options
Cache readModel-specific discounted input rateA 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:

Model30-minute write per 1M tokens12-hour write per 1M tokensCache 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:

bash

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:

bash

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 modelBatch input per 1M tokensBatch output per 1M tokensBatch 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 modelLong-context input per 1MLong-context output per 1MLong-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 choiceCurrent token-price relationshipOperational fit
Standard1xDefault production path
Batch0.5xAsynchronous jobs that can complete within 24 hours
Flex0.5xLower-priority work that tolerates slower responses and resource unavailability
Fast2xUser-facing workloads where lower and more consistent latency justifies the premium
Ultrafast6xHighest-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

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.

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 categoryCurrent 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 TranscribeEstimated $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 LatestFree

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:

ModelStandard token costBatch 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:

ConfigurationCalculated 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 componentCalculationCalculated cost
Input11,111.11 x 5,000 / 1M x $2$111.11
Output11,111.11 x 1,000 / 1M x $10$111.11
Web search11,111.11 x $0.01$111.11
TotalSum of listed components$333.33
Cost per accepted result$333.33 / 10,000Approximately $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:

bash

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:

python

Run the Web-Research Example

bash

The tested output is:

bash

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:

bash

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.

ArchitectureMain cost componentsIs a separate proxy inherently required?
OpenAI model with OpenAI-hosted web searchModel tokens plus OpenAI search calls and search-content tokensNo
OpenAI model analyzing internal files or application dataModel tokens, applicable file-search or storage charges, and application infrastructureNo
An independently operated browser or scraper sending permitted public data to OpenAICollector compute, proxy traffic where needed, parsing, storage, retries, and OpenAI tokensSometimes
Location-specific public-web observations collected by your own systemCollector, suitable location routing, validation, storage, and OpenAI tokensOften 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.

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.

Ready to launch?

Proxies built for real operations.

For teams that depend on stability, not luck.