GPT-6.1 Sol Pricing Is One-Fifth of GPT-6 Astra

If your AI feature budget was built around GPT-6 Astra, it just got a rival that costs about a fifth as much. GPT-6.1 Sol pricing is $2 per million input tokens, $0.10 per million cached input tokens and $10 per million output tokens.

This is for the person who owns the plan and the spreadsheet, not the prompt. Here is what changed and what to do with it.

What happened: GPT-6.1 Sol pricing in numbers

OpenAI's API changelog lists GPT-6.1 Sol (gpt-6.1-sol) as released on September 29, 2026. Standard pricing for prompts up to 272K input tokens is $2 input, $0.10 cached input, $2.50 cache write and $10 output, per million tokens. It is available in the Responses API and Chat Completions API.

A DevDay 2026 roundup on dev.to puts GPT-6 Astra at $10 input and $50 output per million tokens, with no cached input price listed. That is where the one-fifth comes from: $2 against $10, $10 against $50.

GPT-6.1 Sol vs GPT-6 Astra: is it close enough?

The same roundup cites Artificial Analysis, a third-party benchmarking site, for its Intelligence Index: Sol scores 52, Astra 53. Cost per task in that data is $0.72 for Sol and $3.26 for Astra.

Note the second number. The per-task gap is about 4.5x, not 5x, because the two models don't necessarily use the same number of tokens per task. Budget from your own traffic, not from the price list.

One gap in what I could confirm: the sources I read give no context window sizes for either model, so check the pricing page before you plan long-document features.

Estimate your monthly bill with the GPT-6.1 Sol cached input price

Cached input is the line to watch. The cached input price is $0.10, 95% below the $2 standard input rate. Features that resend the same system prompt, policy text or reference documents on every call benefit most.

Here is a small estimator. The volumes are placeholders; replace them with numbers from your logs.

# Prices in USD per 1M tokens, from the OpenAI changelog (prompts up to 272K tokens)
SOL = {"input": 2.00, "cached": 0.10, "output": 10.00}

def monthly_cost(prices, input_m, output_m, cached_share=0.0):
    """input_m and output_m are millions of tokens per month."""
    cached = input_m * cached_share
    fresh = input_m - cached
    return fresh * prices["input"] + cached * prices["cached"] + output_m * prices["output"]

# Example: 100M input, 20M output per month
print(monthly_cost(SOL, 100, 20))        # no caching: 400.0
print(monthly_cost(SOL, 100, 20, 0.6))   # 60% cached: 286.0

The same traffic at Astra's listed $10 and $50 rates, without caching, comes to $2,000 a month. This ignores the $2.50 cache write price, so add that for the first call of each cached prefix.

To trial it, change the model ID in your existing call:

from openai import OpenAI

client = OpenAI()
resp = client.responses.create(
    model="gpt-6.1-sol",
    input="Summarize this change request in three bullets.",
)
print(resp.output_text)

Run it side by side with gpt-6-astra on the same inputs. Astra does not support the none reasoning effort level, so check any request settings you carry over.

When to stay on Astra

A one-point gap on an index is an average, not a promise for your task. Astra was positioned for the hardest end-to-end work: reasoning, coding, computer use, research and document creation. If a feature fails review on Sol and passes on Astra, the extra spend is cheaper than rework.

Also keep Astra where a wrong answer is expensive, such as contract analysis or anything customer-facing with legal weight. Route by task, not by habit.

What to do on Monday morning

1. Pull a week of real prompts and token counts for each AI feature.
2. Run a 50 to 100 case sample through both models and have a reviewer score blind.
3. Move the features that pass on Sol, and keep a named list of those that stay on Astra, with the reason.
4. Lower the forecast, but hold the savings as contingency until a month of billing confirms them.

Pricing can change, so confirm the current rates on OpenAI's pricing page before you commit numbers to a plan.

For anyone shipping AI to production, a fivefold price drop on a near-peer model turns "can we afford this feature" into "can we prove it works," and your eval set is how you answer that.