Updated 2026-11-18. OpenAI published two GPT-6.2 models on the same day: gpt-6.2-astra at $8 per million input tokens and $40 output, gpt-6.2-sol at $2 and $10. Both carry a 1,050,000-token window and both reject reasoning effort none.
gpt-6.2-astra
gpt-6.2-sol
none
# Copy-paste starter: call the cheap one, then the expensive one, and compare. export OPENAI_API_KEY=sk-... curl -s https://api.openai.com/v1/responses \ -H "Authorization: Bearer $OPENAI_API_KEY" -H "Content-Type: application/json" \ -d '{"model":"gpt-6.2-sol","input":"Summarise this ticket in one line."}' \ | python3 -c 'import json,sys; print(json.load(sys.stdin)["output"][0]["content"][0]["text"])'
Swap the model field to gpt-6.2-astra and run it again on the same prompt. That comparison, on your own task rather than a leaderboard, is the only benchmark that matters for the decision below.
Both pages describe the same context window and the same output limit. What separates them is what OpenAI says each is for, and the price you pay for it [1][2].
The model index gives the tie-breaker in one sentence: if you are not sure where to start, use Astra for complex reasoning and coding, and choose Sol to balance capability against cost [3]. The reasoning guide goes further and names a default for reasoning workloads, which is Astra, with gpt-6.1-terra and gpt-6-luna as the cheaper rungs below it [4]. Astra also gets the sentence about building and revising software, using a computer and working with documents, while Sol's page lists web search and computer use as the tools you call through the Responses API [1][2].
gpt-6.1-terra
gpt-6-luna
Both models can also act on the code they touch, which changes what a mistake costs; the failure modes of agent-written code are worth knowing before you point either model at a repository, and I wrote those up in what breaks when an agent writes your code.
A practical rule from those pages: route by consequence rather than by novelty. Sol handles the ticket summaries, the extraction jobs and the agent loops, where a wrong answer costs a retry. Astra earns its four-times input price on the tasks where you would otherwise read the output carefully before trusting it. I have written before about where unattended agent work quietly spends money, and the same arithmetic decides this choice.
The documented shape for a plain text call is short. This is the Python form from the text guide, with the model swapped for today's:
from openai import OpenAI client = OpenAI() response = client.responses.create( model="gpt-6.2-sol", input="Write a one-sentence bedtime story about a unicorn.", ) print(response.output_text)
The reasoning guide uses the same call with an effort level attached, and its example is gpt-6.2-astra [4]:
import OpenAI from "openai"; const openai = new OpenAI(); const response = await openai.responses.create({ model: "gpt-6.2-astra", reasoning: { effort: "low" }, input: "Write a bash script that transposes '[1,2],[3,4],[5,6]'.", }); console.log(response.output_text);
What a successful response contains is documented in the Responses reference, and this is where a reader can be misled. The reference's 200 example shows "model": "gpt-6-astra", which is the earlier model rather than either GPT-6.2 id, and it shows the fields you actually read [6]:
"model": "gpt-6-astra"
{ "id": "resp_67ccd3a9da748190baa7f1570fe91ac604becb25c45c1d41", "object": "response", "status": "completed", "model": "gpt-6-astra", "output": [ { "type": "message", "status": "completed", "role": "assistant", "content": [ { "type": "output_text", "text": "The image depicts a scenic landscape...", "annotations": [] } ] } ], "reasoning": { "effort": null, "summary": null, "context": null }, "store": true, "temperature": 1 }
Read output[0].content[0].text or the SDK's output_text shortcut, and read status before you read the text, because a response can complete with an incomplete body depending on your max_output_tokens. The reference also documents the usage shape for tools, where a request reports input_tokens, output_tokens, reasoning_tokens and total_tokens [6]. Those are the numbers to log, because reasoning tokens are billed as output and they are the ones that surprise people.
output[0].content[0].text
output_text
status
max_output_tokens
input_tokens
output_tokens
reasoning_tokens
total_tokens
I sent both model ids to the API from this machine with no key, to capture what a misconfigured deployment returns rather than what the docs say it returns. Both answered identically, with HTTP 401:
{ "error": { "code": null, "message": "Missing bearer or basic authentication in header", "param": null, "type": "invalid_request_error" } }
That is the first error most teams meet, and it has nothing to do with the model id. A missing or misspelled environment variable produces exactly this, so if you are debugging a new deployment, check that the key reached the process before you question the model name.
Both model pages carry the same sentence: the API rejects requests that set reasoning effort to none [1][2]. Effort is a field with a small set of accepted values and one explicitly refused value, and the refusal arrives as a request error rather than a silent downgrade.
I could not produce that error body myself. Without a key, the request is rejected at authentication before any parameter is validated, which is what the 401 above shows. Treat the rejection as documented rather than observed, and do not expect a warning in your logs if you generate the parameter programmatically from a config file that happens to contain none.
The practical consequence is a validation step in your own code, since the failure mode is a config value that looks reasonable. If you have a settings table where a human picks an effort level, none is the entry that will be selected by someone reasoning that "none" means "do not think about it", and it is the one value the API will not take.
The pricing page has enough structure that a small script pays for itself, because the effective rate depends on four things at once: the model, the tier you are in, whether the request crosses 272,000 input tokens, and whether it runs in a discounted background window. I wrote the script below from the model pages and the pricing page and ran it on this machine.
#!/usr/bin/env python3 """Cost a GPT-6.2 request before sending it. Rates from the OpenAI model pages.""" import argparse, datetime RATES = { # per 1M tokens: input, cached input, cache write, output "gpt-6.2-astra": (8.0, 0.4, 10.0, 40.0), "gpt-6.2-sol": (2.0, 0.1, 2.5, 10.0), } LONG_CONTEXT_THRESHOLD = 272_000 MODES = {"standard": 1.0, "batch": 0.5, "fast": 2.0} WINDOWS = {"soonest": 0.0, "2h": 0.30, "8h": 0.40} def ultrafast_multiplier(when): return 3.0 if when < datetime.date(2027, 3, 1) else 6.0 def price(model, mode, window, input_tokens, cached_tokens, cache_write_tokens, output_tokens, when=None): if model not in RATES: raise SystemExit(f"unknown model {model!r}; known: {', '.join(sorted(RATES))}") for name, value in (("input-tokens", input_tokens), ("cached-tokens", cached_tokens), ("cache-write-tokens", cache_write_tokens), ("output-tokens", output_tokens)): if value < 0: raise SystemExit(f"--{name} must not be negative (got {value})") when = when or datetime.date.today() if mode == "ultrafast": tier = ultrafast_multiplier(when) elif mode in MODES: tier = MODES[mode] else: raise SystemExit(f"unknown mode {mode!r}; known: standard, batch, fast, ultrafast") r_in, r_cached, r_write, r_out = RATES[model] if input_tokens > LONG_CONTEXT_THRESHOLD: r_in, r_cached, r_write, r_out = r_in * 2, r_cached * 2, r_write * 2, r_out * 1.5 billable_input = max(input_tokens - cached_tokens, 0) cost = ( billable_input / 1e6 * r_in + cached_tokens / 1e6 * r_cached + cache_write_tokens / 1e6 * r_write + output_tokens / 1e6 * r_out ) * tier * (1 - WINDOWS[window]) return cost, (r_in, r_cached, r_write, r_out), tier def main(): p = argparse.ArgumentParser() p.add_argument("--model", default="gpt-6.2-astra", choices=sorted(RATES)) p.add_argument("--mode", default="standard") p.add_argument("--window", default="soonest", choices=sorted(WINDOWS)) p.add_argument("--input-tokens", type=int, default=80_000) p.add_argument("--cached-tokens", type=int, default=0) p.add_argument("--cache-write-tokens", type=int, default=0) p.add_argument("--output-tokens", type=int, default=900) p.add_argument("--compare", action="store_true") a = p.parse_args() models = sorted(RATES) if a.compare else [a.model] for m in models: cost, rates, tier = price(m, a.mode, a.window, a.input_tokens, a.cached_tokens, a.cache_write_tokens, a.output_tokens) flag = " long-context rates" if a.input_tokens > LONG_CONTEXT_THRESHOLD else "" print(f"{m:<15} {a.mode:<9} window={a.window:<7} " f"in=${rates[0]:g}/M out=${rates[3]:g}/M x{tier:g}{flag} -> ${cost:.4f}") if __name__ == "__main__": main()
Reading an 80,000-token document and producing a 900-token answer costs this much on the two models, at Standard rates:
$ python3 cost.py --compare --input-tokens 80000 --output-tokens 900 gpt-6.2-astra standard window=soonest in=$8/M out=$40/M x1 -> $0.6760 gpt-6.2-sol standard window=soonest in=$2/M out=$10/M x1 -> $0.1690
Push the same request past 272,000 input tokens and the model page rule applies: input and cache rates double, and output costs 1.5 times the short-context rate, for the whole request [1][2]. The script's rate column now reads the doubled figures:
$ python3 cost.py --compare --input-tokens 300000 --output-tokens 900 gpt-6.2-astra standard window=soonest in=$16/M out=$60/M x1 long-context rates -> $4.8540 gpt-6.2-sol standard window=soonest in=$4/M out=$15/M x1 long-context rates -> $1.2135
That is a jump from $0.6760 to $4.8540 on Astra for a request that grew by about 3.75 times in input size. The tier applies to the entire request rather than to the tokens above the threshold, so a document that sits at 273,000 tokens costs more than one piece of arithmetic suggests. If your pipeline chunks documents at 100,000 tokens, this line does not affect you. If it sends whole repositories, this single sentence on the model page is the most expensive one in the documentation, and it is the same accounting problem I wrote about from the security side in what a scan of AI-written code costs to ignore.
The three cheaper routes compose from there. Batch runs at half the Standard rate, fast mode doubles it, and ultrafast multiplies it by three through February 28, 2027 and by six from March 1, 2027 [1][2][3]. The background windows are a discount on top of the tier rather than a tier of their own: soonest takes none, 2h takes 30 percent below Standard, and 8h takes 40 percent below Standard [5].
soonest
2h
8h
$ python3 cost.py --compare --mode batch --input-tokens 300000 --output-tokens 900 gpt-6.2-astra batch window=soonest in=$16/M out=$60/M x0.5 long-context rates -> $2.4270 gpt-6.2-sol batch window=soonest in=$4/M out=$15/M x0.5 long-context rates -> $0.6068 $ python3 cost.py --compare --window 8h --input-tokens 300000 --output-tokens 900 gpt-6.2-astra standard window=8h in=$16/M out=$60/M x1 long-context rates -> $2.9124 gpt-6.2-sol standard window=8h in=$4/M out=$15/M x1 long-context rates -> $0.7281
One assumption is mine, not OpenAI's. The docs state each discount separately and do not say how they combine, so the script applies the tier multiplier and then the background discount. If you stack batch with an 8h window, confirm the composition with your account team before you budget on it. The script prints the rates it used, so a wrong assumption is visible in the output rather than buried in a total.
The last lever is caching, and its effect is the largest of the four. Re-reading the same document with almost all of it cached turns the 80,000-token call into this:
$ python3 cost.py --compare --input-tokens 80000 --cached-tokens 79000 --output-tokens 900 gpt-6.2-astra standard window=soonest in=$8/M out=$40/M x1 -> $0.0756 gpt-6.2-sol standard window=soonest in=$2/M out=$10/M x1 -> $0.0189
The cache write is not free and the retention window matters: $10 per million tokens on Astra buys 30 minutes, and a 12-hour cache write costs $20 per million tokens for short-context requests at Standard pricing [1]. On Sol those figures are $2.50 and $5 [2]. The decision is whether the same prefix is read again inside the retention window, and a support-ticket pipeline that re-reads a policy document on every request is the case where this pays.
The Sol page lists endpoint support explicitly, and Astra shares the practical shape of it [2]. Chat Completions and Responses are supported, and so is Batch. Realtime, Assistants, fine-tuning, image generation, image editing, speech generation and transcription are not supported on Sol.
For a team migrating an existing integration, that table decides more than the model name does. A fine-tuned pipeline cannot move onto GPT-6.2 at all, and a Realtime voice product cannot call it. The Responses API is where the newer capabilities live, including the multi-agent beta for delegating to subagents with both models, and the tool calls Sol's page names: web search and computer use [1][2]. If you are still on Chat Completions, the model ids work, and you will not get the subagent path.
The same week brought a comparable change on the Anthropic side, where Code Mode stopped refusing to start because of an installed mod and agent teams became a supported combination, which I track in the Code Mode guide.
Both models accept text and images and return text. Audio and video are listed as unsupported input modalities on both pages, which is worth stating because the same models are described as able to use a computer and work with documents, and a reader can reasonably assume more input types than the API accepts [1][2].
Is gpt-6.2-astra worth four times the input price of Sol? On tasks where you would review the output anyway, no. On the tasks OpenAI describes as the hardest projects, meaning multi-step coding and documents with long dependency chains, the cheaper model can cost more in retries and reading time. Test both on your own prompt before you decide.
Which model runs Codex CLI? The reasoning guide says its reasoning models are the best fit for Codex CLI and names Astra as the default starting point for reasoning workloads, with gpt-6.1-terra and gpt-6-luna below it on cost [4]. I have written separately about scanning a repository with the Codex Security CLI.
Why does my request fail with an authentication error? Because the key did not reach the process. I reproduced that exact 401 from this machine with no key, and both model ids return it, so it says nothing about the model.
Can I set reasoning effort to none to save money? No, the API rejects it on both models [1][2]. Lower the effort level instead, and read the reasoning guide for the accepted values it uses in its own examples.
What happens at 272,000 input tokens? Input and cache rates double and output costs 1.5 times the short-context rate for the whole request, so the cost of a long request is not proportional to its length. The third output in recipe two shows the size of the step.
Does the 1,050,000-token window mean I can send a million tokens? The maximum input is 922,000 tokens on both model pages, which is the number to validate against, and the long-context rates apply from 272,000 upward.
[1] OpenAI, GPT-6.2 Astra model page, fetched 2026-11-18. Source of the positioning sentence, modalities, context and token limits, the May 18, 2026 knowledge cutoff, the pricing table and cache retention figures, the long-context rate rule, the batch, fast and ultrafast multipliers, the reasoning effort none rejection and the discounted background windows.
[2] OpenAI, GPT-6.2 Sol model page, fetched 2026-11-18. Source of Sol's positioning, its Jun 01, 2026 cutoff, its pricing and cache figures, the endpoint support table, the none rejection and the tool list.
[3] OpenAI, models index, fetched 2026-11-18, referenced for the sentence telling readers which of the two to start with.
[4] OpenAI, reasoning guide, fetched 2026-11-18, referenced for the reasoning call example with an effort level, the default recommendation of Astra for reasoning workloads, and the cheaper gpt-6.1-terra and gpt-6-luna alternatives.
[5] OpenAI, background guide, fetched 2026-11-18, referenced for the soonest, 2h and 8h completion windows and their 0, 30 and 40 percent discounts.
[6] OpenAI, Responses create reference, fetched 2026-11-18, referenced for the response object shape and the usage fields including reasoning tokens. Its 200 example uses the earlier gpt-6-astra model id.
gpt-6-astra
Both models are one line of configuration away, and the line that decides your bill is the routing rule rather than the model name. If you want the routing, the cost script and the cache strategy set up against your own workload, send a written intake and we will price it on your traffic instead of on an example.
Maxpertise is an AI-native engineering company. We embed native AI engineers inside your team, live in about 10 days. Please enable JavaScript to view the site, or email contact@maxpertise.net.