Short answer: For demanding work that benefits from deep analysis, consider GPT-6 Astra. OpenAI describes GPT-6.1 Sol as a lower-cost option for complex work; GPT-6.1 Terra as a fast, efficient choice for visual reasoning, computer use, and natural writing; and GPT-6 Luna as an efficient model for focused, high-volume tasks. Treat these descriptions as a shortlist—not a guarantee of results on your workload—and test candidates on representative examples. If coding is your task, evaluate candidates on your own coding workload rather than assuming a model-specific advantage. (OpenAI model guide; API model catalog)
This guide covers OpenAI API model information available on November 12, 2026. Prices below are the dollar amounts displayed by OpenAI for standard processing when context is under 272K tokens; check the linked model pages before deploying because catalog details and prices can change. (OpenAI API pricing)
OpenAI API model shortlist
| Model | API model ID | A reasonable starting point when… | Listed input / output price per 1M tokens |
|---|---|---|---|
| GPT-6 Astra | gpt-6-astra |
The work calls for complex reasoning or coding, especially on demanding tasks. | $10 / $50 |
| GPT-6.1 Sol | gpt-6.1-sol |
You have a complex task and want to balance capability and cost. | $2 / $10 |
| GPT-6.1 Terra | gpt-6.1-terra |
The task involves visual reasoning, precise computer use, or clear, natural writing. | $1 / $5 |
| GPT-6 Luna | gpt-6-luna |
The work is focused and high-volume, or cost efficiency is a priority. | $0.10 / $0.50 |
OpenAI’s API pricing information lists a 1.05M-token context length and 128K maximum output for Astra and Luna. Do not assume those limits also apply to Sol or Terra; check each model’s current specifications. Verify support for any required tools and features against the exact model version and endpoint rather than assuming the same support across all four models. (API model catalog; model specifications; OpenAI API pricing)
These are starting points, not universal winners. OpenAI says its latest models support text and image input and text output, along with multilingual capabilities and vision. For image generation, realtime voice, transcription, embeddings, or other specialized jobs, check the relevant category in OpenAI’s model catalog rather than assuming a general-purpose model is the right fit. (API model catalog; all models)
How to choose by task
- Complex reasoning or coding: Consider Astra for demanding work and deep analysis. If cost matters on a complex project, compare Sol: OpenAI describes it as offering near-Astra performance at lower cost. For coding, compare candidates on the same representative workload; model descriptions alone do not establish which will perform best for your application. (OpenAI model guide; API model catalog)
- Visual reasoning, computer use, or concise writing: Consider Terra. OpenAI’s model-selection guidance also suggests it for screen-based workflows and scoped code fixes. Check the specific task and endpoint requirements before relying on those capabilities. (OpenAI model guide; API model catalog)
- Focused, high-volume tasks: Consider Luna when efficiency or cost is important. OpenAI describes it as suited to scoped tasks, triage, and frequent automations. Its listed input and output prices are the lowest of these four, but low price alone does not establish that it meets your quality, latency, or reliability needs. (OpenAI model guide; API model catalog)
- Image, audio, or other specialized workflows: Check OpenAI’s specialized model categories and their API instructions. A model name in a catalog—or a listing from a third-party service—does not by itself establish that a model ID is usable through your OpenAI API project. (All OpenAI models)
Estimate token cost before scaling
At the listed standard rates, a request using 20,000 input tokens and 2,000 output tokens would have these illustrative model charges, before any other applicable fees:
| Model | Calculation | Illustrative total |
|---|---|---|
| Astra | (20,000 × $10 + 2,000 × $50) ÷ 1,000,000 | $0.30 |
| Sol | (20,000 × $2 + 2,000 × $10) ÷ 1,000,000 | $0.06 |
| Terra | (20,000 × $1 + 2,000 × $5) ÷ 1,000,000 | $0.03 |
| Luna | (20,000 × $0.10 + 2,000 × $0.50) ÷ 1,000,000 | $0.003 |
This is a worked estimate using OpenAI’s published per-million input and output token rates; it is not a measured API bill. Actual usage and final charges depend on the request and applicable pricing rules. The listed rates apply to standard processing for context lengths under 272K tokens. (OpenAI API pricing)
The example also shows why input and output usage should be estimated separately: output tokens have a different listed rate from input tokens for all four models. If a more capable model materially reduces retries, review work, or downstream errors in your application, its higher per-token rate may still be worthwhile—but establish that with your own evaluation rather than assuming it.
Production checks before you commit
- Confirm the exact model ID and availability. OpenAI’s API reference documents
GET /modelsto list models andGET /models/{model}to retrieve one. Use the current API documentation and your intended project to confirm the model you plan to call; a model listing alone does not demonstrate compatibility with every endpoint or feature. (OpenAI Models API reference) - Confirm endpoint and feature support. Decide which API endpoint your application will use, then check that the chosen model supports it and the features your request needs. OpenAI says its latest models are available via the Responses API and Client SDKs, but check the model-specific documentation for your exact integration. (API model catalog)
- Review pricing and limits for the workload. Estimate typical and worst-case input and output token use, including long-context requests. Check current rate limits and other applicable usage constraints for the account and model you will deploy; don’t rely on old model-page limit figures as current guidance.
- Evaluate representative cases. Compare a small shortlist using the same real or carefully prepared examples. Score the outcomes that matter to your product—such as correctness, format compliance, latency, and cost—and include difficult cases, not just easy demonstrations. These are evaluation dimensions to measure, not claims about benchmark results.
- Recheck lifecycle and pinning guidance. If stable behavior matters, consult current official guidance on model versions and snapshots. A previous OpenAI GPT-4 page, for example, described snapshots as a way to lock a specific version but marked GPT-4 “Shut down”; old model details should not be treated as evidence of current availability. (GPT-4 model page)
Practical rule: choose the least expensive candidate that passes your application’s evaluation at the quality and latency you require. Move up to a more capable model when the measured improvement justifies its added cost—not simply because it is the flagship.