OpenAI API Pricing Changes (September 2026): What Changed and What It Costs

September 2026 Release Timeline

This is the latest event in the September pricing timeline. OpenAI first released GPT-6 Sol and GPT-6 Luna on September 22, then added GPT-6.1 Sol on September 29 as a separate model. The official API changelog records both releases and their prices. Luna remains the high-volume tier; GPT-6 Astra remains the flagship for the hardest work; GPT-6.1 Sol is the newer lower-cost complex-work route.

For a quick provider-level cross-check, compare OpenAI, Claude, Gemini, and other model prices in the Model Pricing Comparison before you update product margins or plan limits.

For the provider-specific table, review OpenAI API pricing with current model rows and then rebuild your monthly estimate from real input tokens, output tokens, and request volume.

For a source-linked view of normalized provider fields and verification dates, use the AI API pricing dataset as a planning reference, then confirm final billing details in OpenAI's own sources.

Latest Update: GPT-6.1 Sol on September 29, 2026

The GPT-6.1 Sol model page lists a 1.05M-token context window and the same $2 input / $10 output short-context rate as GPT-6 Sol, but cached input falls from $0.20 to $0.10 per million tokens. Prompts above 272K input tokens use twice the input and cache rates and 1.5 times the output rate for the full request. Batch and Flex are 50% below Standard; Fast is 2x Standard and is unavailable with EU data residency.

What Changed on September 22, 2026

OpenAI added two new priced API models. It did not rename GPT-5.6 Sol or Luna in place, so migration requires an explicit model-ID change and representative evaluation.

OpenAI records the release and short-context prices in the API changelog. Confirm the current component and service-tier rates on the official API pricing page, and use the GPT-6 Sol model page and GPT-6 Luna model page to verify each historical route before changing production.

Current GPT-6 API Pricing (Verified October 1, 2026)

Verified October 1, 2026. These are OpenAI's published Standard text-token prices in USD per 1M tokens. The context tier is selected from input-token length and reprices the whole request.

Use the OpenAI API pricing reference for the broader provider table while this article keeps dated change context.

Use the source-linked pricing dataset for normalized fields and verification dates, then confirm billing decisions against OpenAI's official model pages and your invoice.

How the September Prices Compare with GPT-5.6

OpenAI describes GPT-6 Sol and Luna as 50% cheaper than GPT-5.6 promotional pricing. Treat that as a cross-generation comparison, not a price change applied to the old IDs. The current model catalog lists the models separately.

What Actually Changed—and What Did Not

The September releases change the available model ladder and the price of cached input on the newer Sol route. They do not prove that every existing workload should migrate or that every dollar saved on tokens survives changes in output length, retries, and task success.

• New model IDs: gpt-6-sol and gpt-6-luna on September 22, followed by gpt-6.1-sol on September 29; GPT-6 Astra remains a separate flagship route.
• GPT-6.1 Sol Standard short-context prices are $2 input, $0.10 cached input, $2.50 cache writes, and $10 output per million tokens.
• GPT-6.1 Sol cached reads cost 5% of ordinary input; GPT-6 Sol and Luna cached reads cost 10%. Cache writes are 1.25 times ordinary input for all three models.
• Prompts above 272K input tokens move the whole request to higher input, cache, and output rates.
• Batch and Flex are half of applicable Standard rates; Fast is twice applicable Standard rates.
• No price card can establish equal quality, output length, retry rate, latency, or cost per accepted task.

When Switching Does Not Save as Much

A lower token rate is not the same as a lower cost per successful task. The calculator examples isolate price by holding token volume constant; a production migration can change the workload itself.

• Output-heavy workloads can erase part of a saving if the candidate produces longer answers or more billed reasoning tokens.
• Prompts above 272K input tokens move the whole GPT-6 request to long-context rates.
• A 90% cached-input discount matters only when the prefix qualifies and the workload achieves real cache hits.
• A cheaper model that needs more retries, tool loops, or Astra fallbacks can raise cost per completed task.
• Batch or Flex can lower eligible asynchronous work, but neither is a substitute for an interactive route.
• Regional processing, provider tools, taxes, and negotiated terms are outside the token-only examples.
• Capability and reliability cannot be inferred from price. Run representative evaluations before moving production traffic.

For the operating side of this problem, use the AI API cost control checklist to separate provider pricing from product behavior.

Cost Formula After a Pricing Update

After any OpenAI API pricing update, rebuild the estimate from the request shape. Keep input and output tokens separate because they can be priced differently and they respond to different product decisions.

monthly cost = requests × (((fresh input ÷ 1M) × input rate) + ((cached input ÷ 1M) × cached-input rate) + ((output ÷ 1M) × output rate))

Split fresh and cached input before applying the formula. For GPT-6.1 Sol, an eligible cached read is priced at 5% of ordinary input; GPT-6 Sol and Luna use 10%. Cache writes are billed separately at 1.25 times ordinary input. Do not apply the read discount to every repeated-looking token.

Model repeated-prefix assumptions in the Prompt Caching Savings Calculator. If the result becomes a product packaging decision, move it into the AI Budget Planner so monthly cost, gross margin, usage limits, and plan design stay connected.

Astra to Sol/Luna: Three Reproducible Monthly Cost Examples

These light, medium, and heavy planning scenarios use the site's canonical Pricing V2 projection and existing tier-aware token-cost helper. Each holds input tokens, output tokens, and request volume constant to isolate the published rate-card difference. They are not benchmarks and do not assume equal capability.

monthly cost = requests × ((input tokens ÷ 1,000,000 × input rate) + (output tokens ÷ 1,000,000 × output rate))
monthly savings = current monthly cost - target monthly cost
savings % = monthly savings ÷ current monthly cost × 100

Use your production shape to test an available current-versus-target route in the Model Switch Cost Calculator; keep the verified Sol and Luna scenarios above as the GPT-6 rate-card baseline. If you also need the same-day cross-provider launch context, read the GPT-6 vs Claude Opus 5.5 pricing comparison.

Batch API Pricing and Discount Considerations

Batch API pricing matters when your workload does not need an immediate response. Examples include nightly enrichment, evaluations, report generation, support-ticket labeling, embedding refreshes, and large CSV-style processing. If OpenAI offers a Batch API discount for the model and endpoint you use, the same job may cost less than a synchronous request route.

Before assuming savings, check the official OpenAI Batch API documentation and current pricing page for supported endpoints, completion windows, model eligibility, limits, and discount rules.

Use the Batch Token Calculator to estimate row-level input and output tokens before you submit a large async workload.

Who Should Switch—and Who Should Not

Use the rate-card difference to decide whether an evaluation is worth funding. Do not use it as the final routing decision.

• Evaluate Luna for focused, repeatable, high-volume work where cost and throughput dominate.
• Evaluate GPT-6.1 Sol for demanding everyday coding and agent work that does not need Astra on every turn, especially when repeated prefixes produce verified cache hits.
• Keep GPT-6 Sol only where its existing route has been evaluated and the migration benefit does not justify a change; the official docs do not mark it retired.
• Keep Astra for the hardest tasks when measured task success, rework, or risk justifies the premium.
• Do not switch solely from a benchmark headline; test your prompts, tools, schemas, and acceptance criteria.
• Do not assume equal token use. Measure output length, retries, fallbacks, cache hits, and long-context frequency.
• Roll out by route or task class, then compare cost per accepted task before widening traffic.

Astra-to-Sol or Astra-to-Luna savings create an evaluation budget. Spend part of it on regression cases and rollout monitoring; a failed task that triggers another model call is not a free failure.

The September Update Decision

The September timeline is now concrete: GPT-6 Sol and Luna launched on September 22, and GPT-6.1 Sol followed on September 29 with the same short-context input and output rates as Sol but a lower cached-input rate. These are serious routing candidates, not automatic replacements.

Price the current and target routes with the same workload first. Then rerun the comparison with measured candidate output length, cache hits, retries, and task success. The decision is finished only when cost per accepted task improves—not when one row in a token table is lower.

FAQ