OpenAI models: GPT-6 tiers and how to choose
What you’ll learn
Section titled “What you’ll learn”- How OpenAI’s GPT-6 family is organized by tier, and what the API model IDs are.
- Which image, audio, embedding, moderation and open-weight models sit beside it.
- How service tiers (Standard, Batch, Flex, Fast) change price and latency for the same model.
- Which older models are shut down or scheduled to shut down, and how to stay ahead of that.
- A tested Responses API pattern for a cost-sensitive background job.
Summary
Section titled “Summary”OpenAI ships its main language models as one family with named tiers. In the GPT-6 generation the tiers are Astra (flagship), Sol, Terra and Luna (lightweight), with point releases such as GPT-6.1 Sol and GPT-6.1 Terra arriving within weeks of the first GPT-6 models in September and October 2026. Reasoning is built into these models and controlled with a reasoning.effort setting, so the separate o-series line is now legacy.
Around the language models sit specialist families: GPT Image for image generation and editing, Sora for video, realtime and transcription models for audio, text-embedding-3 models for retrieval, omni-moderation for safety screening, and the open-weight gpt-oss models you can run yourself.
One caution shapes this whole page. When checked in November 2026, OpenAI’s own pages differed on which GPT-6 tiers were callable through the API and which were limited to ChatGPT, Codex or an access program. Confirm on the OpenAI models page before designing around a tier. The cross-provider selection method is on LLM model selection; this page is the OpenAI-specific detail.
The GPT-6 family
Section titled “The GPT-6 family”Model IDs below are as listed in the openai Python SDK 3.51.0 (generated from OpenAI’s API specification, November 13, 2026). Prices are per million input / output tokens at the Standard tier, from OpenAI’s pricing and model pages in November 2026.
| Tier | Current model | API ID | Positioning | Standard price |
|---|---|---|---|---|
| Flagship | GPT-6 Astra | gpt-6-astra |
The hardest end-to-end reasoning and coding work | $10 / $50 |
| Upper middle | GPT-6.1 Sol | gpt-6.1-sol |
In-depth research and complex coding | Check the pricing page |
| Middle | GPT-6.1 Terra | gpt-6.1-terra |
Fast, capable everyday work and computer use at a lower price | $1 / $5 (cached input $0.05) |
| Lightweight | GPT-6 Luna | gpt-6-luna |
High-volume classification, routing and extraction | Check the pricing page |
Shared facts worth knowing, from the model pages:
- Context: about 1.05M tokens on Astra and Terra; Terra’s maximum output is 128K tokens.
- Superseded IDs:
gpt-6-solis still listed but GPT-6.1 Sol replaces it. The GPT-5.6 tiers (gpt-5.6-sol,gpt-5.6-terra,gpt-5.6-luna) are the previous generation. - Restricted variants:
gpt-6-cyber(vulnerability research for vetted security teams) and research-oriented models appear in the SDK but are not general-purpose endpoints. - Reasoning effort: the SDK accepts
none,minimal,low,medium,high,xhighandmax. Not every model accepts every value; the model page lists what each supports. - Where else: the same family appears in ChatGPT, in Codex, and as Azure OpenAI deployments in Microsoft Foundry, each with its own availability and retirement dates.
GitHub Copilot’s model list in November 2026 shows GPT-6 Astra, GPT-6 Luna, GPT-6 Sol, GPT-6.1 Sol and GPT-6.1 Terra, which is a useful cross-check that these tiers are in production use outside OpenAI’s own apps.
Other model families
Section titled “Other model families”Families and IDs as listed in the openai SDK 3.51.0, with shutdown dates from its deprecation notes (which link to OpenAI’s deprecations page).
| Need | Current models | Notes |
|---|---|---|
| Image generation and editing | GPT Image 2.6 (gpt-image-2.6-sunburst, gpt-image-2.6-flare), GPT Image 2.5, GPT Image 2, gpt-image-1.5, gpt-image-1-mini |
gpt-image-1 shut down October 23, 2026; DALL-E 2 and 3 retired May 12, 2026 |
| Video | sora-2, sora-2-pro |
Check current API availability before building on it |
| Speech to speech | gpt-realtime-2.1, gpt-realtime-2.1-mini, gpt-realtime-2 |
gpt-realtime and gpt-realtime-mini shut down January 20, 2027 |
| Speech to text | gpt-transcribe |
whisper-1 and the gpt-4o-*-transcribe models shut down February 26, 2027 |
| Text to speech | gpt-4o-mini-tts, tts-1, tts-1-hd |
All announced for shutdown on January 6, 2027; check the deprecations page for the replacement |
| Embeddings | text-embedding-3-large (up to 3,072 dimensions), text-embedding-3-small (up to 1,536) |
Changing embedding model means re-embedding the corpus |
| Moderation | omni-moderation-latest |
Text and image risk categories with scores |
| Open weights | gpt-oss-120b (116.8B total, 5.1B active per token), gpt-oss-20b (20.9B total, 3.6B active) |
Apache 2.0 plus OpenAI’s usage policy; the larger model fits on one 80 GB GPU, the smaller runs in about 16 GB |
Legacy and shut-down language models (November 2026)
From the deprecation notes in the openai SDK 3.51.0. Dates are announced shutdown dates; after them, requests fail.
| Models | Shutdown |
|---|---|
gpt-4.1-nano, o4-mini, o3-mini, o1, gpt-4-turbo, gpt-4, gpt-3.5-turbo |
October 23, 2026 (already shut down) |
gpt-5, gpt-5-mini, gpt-5-nano, o3 |
December 11, 2026 |
gpt-4.1, gpt-4.1-mini, gpt-4o, gpt-4o-mini |
January 14, 2027 |
gpt-5.1, gpt-5.4-nano |
April 1, 2027 |
gpt-5.3-chat-latest, gpt-5.2-chat-latest |
August 10, 2026 (already shut down) |
gpt-5.1-codex, gpt-5-chat-latest, gpt-4o search previews |
July 23, 2026 (already shut down) |
The o-series (o1, o3, o4-mini) introduced separate reasoning models in 2024 and 2025. Since reasoning moved into the main GPT models, new work should use a GPT-6 tier with an effort setting instead.
Service tiers: the same model at different prices
Section titled “Service tiers: the same model at different prices”OpenAI sells the same model through several processing tiers. Choosing one is as much a cost decision as choosing the model.
| Tier | How you get it | Price versus Standard (as listed for Terra, November 2026) | Trade-off |
|---|---|---|---|
| Standard | service_tier default or auto |
1× | Normal latency |
| Batch | Batch API (asynchronous jobs) | 0.5× | Results arrive later; not interactive |
| Flex | service_tier="flex" |
0.5× | Slower, and requests can fail with 429 “Resource Unavailable” when capacity is short (not billed); beta with limited model availability |
| Fast | service_tier="fast" (reported back as priority) |
2× | Faster output for latency-critical work |
| Ultrafast | service_tier="ultrafast", access-controlled |
Higher again (Astra Ultrafast lists $60 / $300) | Only on selected models |
The response body reports the tier actually used, which can differ from the one requested. Log it, because it is what you are billed for.
Running the sample
Section titled “Running the sample”The sample uses the openai Python package 3.51.0 on Python 3.11 with the Responses API. It requires an API key and was not executed against the OpenAI API. It was run against a mocked HTTP transport that returned a Flex 429, a standard-tier success and an incomplete response, confirming the fallback, the request fields and the incomplete-response branch. Set OPENAI_API_KEY and run python nightly_copy.py.
Worked example: a nightly job on Flex
Section titled “Worked example: a nightly job on Flex”An invented shop, OrdersPortal, rewrites a few thousand product descriptions every night. Nobody waits for the results, so latency does not matter, but cost and completeness do. That profile fits a mid tier at low effort on Flex, with a fallback to Standard when Flex has no capacity.
# nightly_copy.py - rewrite OrdersPortal product descriptions overnight on Flex, falling back to standard# Requires OPENAI_API_KEY; not executed against the API.import osimport openaifrom openai import OpenAI
MODEL = os.environ.get("COPY_MODEL", "gpt-6.1-terra") # model ID lives in configurationclient = OpenAI(timeout=900, max_retries=0) # Flex can be slow; we own the retry policy
def rewrite(sku: str, text: str) -> str | None: request = dict( model=MODEL, instructions="Rewrite the product description in plain US English, under 60 words. Keep every fact.", input=text, reasoning={"effort": "low"}, max_output_tokens=2000, # covers reasoning plus the visible answer ) try: response = client.responses.create(**request, service_tier="flex") except openai.RateLimitError: # 429: Flex capacity or a rate limit response = client.responses.create(**request, service_tier="default") if response.status == "incomplete": print(f"{sku}: incomplete ({response.incomplete_details.reason}), queued for retry") return None print(f"{sku}: tier={response.service_tier} out={response.usage.output_tokens}") return response.output_text
catalog = { "MUG-01": "Ceramic mug. 350 ml. Dishwasher safe. Ships in recycled box.", "TEE-07": "Organic cotton tee, unisex sizes XS-3XL, printed in Ohio.",}for sku, text in catalog.items(): result = rewrite(sku, text) if result: print(" ", result)Output from the mocked run (the model text is scripted; the control flow is real):
MUG-01: tier=default out=212 A 350 ml ceramic mug that is dishwasher safe, shipped in a recycled box.TEE-07: incomplete (max_output_tokens), queued for retryWhat the example teaches:
- Own the retry policy. The SDK retries eligible 429 and 503 responses on its own. With
max_retries=0the application decides: fall back from Flex to Standard once, instead of nested retry loops multiplying requests. - Not every 429 is Flex capacity. A quota or billing error also returns 429 and will fail again on Standard. In production, inspect the error code and stop on quota errors rather than retrying.
incompleteis not an error. A response cut off bymax_output_tokensstill returns HTTP 200 withstatusset toincomplete. Reasoning tokens count toward that limit, so a higher effort needs a higher limit.- The model ID is configuration. With the shutdown dates above, an ID hard-coded today is a production incident next year.
How to choose
Section titled “How to choose”- Start from the task category on LLM model selection: language, image, speech, embedding or moderation.
- For language work, start at Terra or Luna and run your graded test set. Move to Sol or Astra only for the cases that fail, and sweep
reasoning.effortbefore moving up a tier. - Pick the service tier from the latency need: Batch or Flex for background work, Standard for interactive, Fast only where latency is the product.
- Check availability for your channel. API, ChatGPT, Codex and Azure OpenAI differ in which tiers they offer and when.
- Record the shutdown date of every model you deploy, and set a reminder well before it.
Trade-offs
Section titled “Trade-offs”| Choice | Gain | Cost |
|---|---|---|
| Higher tier (Astra, Sol) | Better results on long, ambiguous, multi-step work | Price, latency, and in some channels restricted access |
| Lower tier (Terra, Luna) | Price and speed; enough for most narrow tasks | More prompt and evaluation work on hard cases |
| Higher reasoning effort | More thorough answers and tool use | Output tokens, time, and a larger max_output_tokens |
| Flex or Batch | Half the price | Latency, capacity failures (Flex), asynchronous handling (Batch) |
| OpenAI API directly | Newest models and features first | A separate vendor relationship |
| Azure OpenAI in Foundry | Azure contracts, networking, regions and identity | Different deployment names, regional availability and retirement dates |
gpt-oss self-hosted |
Data stays on your hardware; full control of version | You run the GPUs, scaling and updates; lower ceiling than the hosted flagship |
Failure modes and operations
Section titled “Failure modes and operations”- Shutdowns break hard-coded IDs. Several widely used models (o4-mini, gpt-4.1-nano) shut down on October 23, 2026, and more follow in December and January. Inventory every caller, including batch jobs and Azure deployments.
- Channel confusion. A tier that exists in ChatGPT may not be callable in the API for your organization, or only through an access program. Test with your own key before committing a design.
- Incomplete responses treated as complete. Check
statusandincomplete_details.reason;output_texton a truncated response is a partial answer. - Tier drift. The tier in the response can differ from the one requested. If you budget on Flex but are served at Standard, your bill doubles quietly.
- Audio stack churn. Most transcription, TTS and early realtime model IDs have shutdown dates between January and February 2027. Voice features need a migration plan now.
- Embedding lock-in. Vectors from different embedding models are not comparable; changing models means re-embedding everything.
When not to use OpenAI’s hosted models
Section titled “When not to use OpenAI’s hosted models”- Data must not leave your hardware. Use
gpt-ossor another open-weight model on your own infrastructure; see Running LLMs locally. - You are already standardized on another cloud’s governance and the same quality is available there. Azure OpenAI, Bedrock or Google Cloud may fit compliance better.
- A rule or a small model already passes. A frontier API call for a fixed lookup adds cost, latency and a dependency for nothing.
Interview questions
Section titled “Interview questions”1. How is the GPT-6 family organized, and how do you pick a starting tier? Four named tiers from Astra (flagship) through Sol and Terra to Luna (lightweight), with point releases such as 6.1 for some tiers. Start low (Terra or Luna) for narrow or high-volume work and evaluate on a graded test set; escalate only failing cases to Sol or Astra, and sweep reasoning effort before changing tier.
2. What does service_tier do, and when would you use Flex?
It selects the processing tier for the same model: Standard, Flex (cheaper, slower, can be refused for capacity), Fast (faster, more expensive) and others. Use Flex for background work where latency does not matter and the job can retry or fall back, and log the tier the response reports.
3. A response comes back with HTTP 200 but the text ends mid-sentence. What happened?
The response is most likely incomplete with reason max_output_tokens: reasoning plus visible output hit the limit. Check status, raise the limit or lower the effort, and never treat output_text as final without checking.
4. Senior scenario: OrdersPortal runs three OpenAI workloads: a customer chat assistant (interactive, peak at lunchtime), a nightly catalog rewrite (thousands of items, no deadline before 6 a.m.) and a weekly fraud review (few items, high stakes). Finance wants the bill cut by 40% without hurting the assistant. Design the tiering.
Treat model tier and service tier as separate dials per workload. The chat assistant stays on Standard with a mid tier such as Terra; tune effort per intent and cache the stable system prompt rather than downgrading the model, and keep Fast only if latency measurements show customers abandoning. The nightly rewrite moves to Flex at low effort, with exponential backoff and a cut-over to Standard only after a deadline, for example 4 a.m., so most of the job runs at half price and the 6 a.m. deadline still holds; move it to the Batch API if the results can wait longer. The fraud review is low volume, so its cost is small: keep it on Sol or Astra at high effort, because a cheaper model’s mistakes cost more than the tokens saved. Prove the savings with per-workload cost dashboards keyed on the service_tier the responses report, plus each workload’s graded test set re-run after every change.
Key takeaways
Section titled “Key takeaways”- GPT-6 ships as tiers (Astra, Sol, Terra, Luna) with point releases; reasoning is built in and tuned with
reasoning.effort. - Confirm API availability per tier on OpenAI’s models page; channels differ.
- Service tiers change cost as much as model tiers do: Batch and Flex are half price, Fast doubles it.
- Many older text and audio models shut down between October 2026 and April 2027; keep IDs in configuration with their dates.
- Check
statuson every response; incomplete answers arrive as successes.
Related pages
Section titled “Related pages”- LLM model selection
- OpenAI introduction
- OpenAI API key setup
- Codex (coding agent) and the original Codex model (historical)
- ChatGPT
- Anthropic models, Google models and Microsoft MAI models
Official references
Section titled “Official references”Checked on November 16, 2026. OpenAI’s lineup changes often; verify before production decisions.