GPT-6.1 Sol vs Terra vs Luna: which OpenAI model should you start with?

Start with the cheapest GPT-6 model that passes your own test set, and move up one tier at a time. On OpenAI's pricing page (read 2026-10-30) that ladder is Luna at $0.10 input and $0.50 output per million tokens, Terra at $1 and $5, Sol at $2 and $10, and Astra at $10 and $50. OpenAI's pages do not tell you when Terra beats Sol, so the choice has to come from your evals. This post gives you the verified numbers and a routine for doing that.

I did not call the API (no key in this session). The prices, limits and dates are from OpenAI's pages; the one script I ran uses a stub model and invented pass rates, which I say clearly where it appears.

What are the four GPT-6 models, side by side?

From OpenAI's models page and pricing page on 2026-10-30. Prices are USD per 1M tokens, Standard tier, prompts up to 272K input tokens.

Notes on the table:

• All four list functions, web search, file search and computer use as tools.
• The models page says the latest OpenAI models take text and image input and produce text output. It gives no per-model modality list.
• On the Terra page, a text-only summary I fetched listed its effort levels slightly differently from the models-page table (one omitted medium from the list while naming it the default). Check the Terra page for the exact list before you pin a value.
• Astra and Sol do not accept none effort per the effort lists above and the GPT-6 prompting guide on this site. If you are porting 5.x code that sets none or minimal, that is where 400 errors come from.

The longer-context rates are worth a line. Above 272K input tokens, OpenAI's page lists 2x on input and cached input and 1.5x on output. Sol becomes $4 input and $15 output, Terra $2 and $7.50.

What changed in the last few weeks?

Dates from OpenAI's changelog, read 2026-10-30:

• Sep 22: GPT-6 Sol (gpt-6-sol) and GPT-6 Luna released. Standard pricing for Sol was $2 input, $0.20 cached input, $10 output; Luna $0.10, $0.01, $0.50.
• Sep 25: a bug fix for image encoding that had degraded image understanding in GPT-6 Sol and GPT-6 Luna.
• Sep 29: GPT-6.1 Sol released "for complex coding and professional work at a lower cost than GPT-6 Astra". Same day: Ultrafast mode for GPT-6 Astra in the Responses API via service_tier: "ultrafast".
• Oct 8: Ultrafast mode for GPT-6.1 Sol in the Responses API.
• Oct 16: Ultrafast mode added to the Agents API through agent.service_tier.
• Oct 20: 12-hour prompt caching in the API; 12-hour cache writes cost 2.5x the input price.
• Oct 22: the Decisions API generally available with gpt-6-luna.
• Oct 26: GPT-6.1 Terra released.

Note what is not on that list: a retirement notice for gpt-6-sol. Yet the models page lists gpt-6.1-sol and no gpt-6-sol, while the pricing page still has a gpt-6-sol row with cached input at $0.20 instead of Sol 6.1's $0.10. I cannot tell you from the pages whether gpt-6-sol is being phased out. Pin the ID you actually tested, and look at your account's model list.

What does Ultrafast cost?

Ultrafast is listed on the pricing page only for Astra and 6.1 Sol, at 6x Standard. Per 1M tokens, short context:

OpenAI describes the purpose as reducing the time between generated output tokens. I have no latency measurements, and the pages I read give none, so I will not claim a speed-up factor. Terra and Luna have no Ultrafast row. If you need low latency on a cheap model, test the standard tier of Terra or Luna first; it may already be fast enough.

Which model should I pick for which job? A starting table

This is judgement, labelled as such. OpenAI's descriptions are the only vendor evidence; the rest is a sensible default to test, not a finding.

Why not start at Astra "to be safe"? Because at a 2,000-token input and 400-token output, the same call costs $0.0400 on Astra, $0.0080 on Sol, $0.0040 on Terra and $0.0004 on Luna (arithmetic from the table prices). At 100,000 calls a day that is the gap between $4,000, $800, $400 and $40 a day, before caching.

How do you prove a cheaper tier is good enough?

Pick 40 to 50 real inputs, define pass/fail per input, then walk up the ladder until a tier clears your threshold. The migrating prompts guide covers building the set. Here is the loop as a script. The call_model function is a stub with invented pass rates, so the output below demonstrates the control flow and cost arithmetic, not how these models perform.

PRICES = {  # input, output USD per 1M tokens (OpenAI pricing page, 2026-10-30)
    "gpt-6-luna": (0.10, 0.50),
    "gpt-6.1-terra": (1.00, 5.00),
    "gpt-6.1-sol": (2.00, 10.00),
    "gpt-6-astra": (10.00, 50.00),
}
LADDER = ["gpt-6-luna", "gpt-6.1-terra", "gpt-6.1-sol", "gpt-6-astra"]
THRESHOLD = 0.90

def run(model, cases, call_model):
    ok = tin = tout = 0
    for c in cases:
        passed, i, o = call_model(model, c)  # replace with a real Responses API call
        ok += passed
        tin += i
        tout += o
    pi, po = PRICES[model]
    return ok / len(cases), (tin * pi + tout * po) / 1_000_000

for m in LADDER:
    rate, cost = run(m, CASES, call_model)
    print(m, rate, cost)
    if rate >= THRESHOLD:
        break

Real output of the full script with the stub (40 cases, 2,000 input and 400 output tokens each):

gpt-6-luna      pass=0.70 cost_for_40_cases=$0.0160 fail
gpt-6.1-terra   pass=0.93 cost_for_40_cases=$0.1600 PASS
-> stop here: gpt-6.1-terra is the cheapest tier at or above 90%

The cost lines are real arithmetic from the stated prices. The pass rates are made up. Your real run will also need to compare effort levels, since a cheaper tier at high effort may cost more than a pricier tier at low once reasoning tokens are billed as output. Sweep effort inside each tier before declaring a winner.

Three guardrails: use the same prompt across tiers on the first pass, record the model ID with every result, and re-run the set whenever you change a model ID or a vendor ships a new snapshot.

What about caching with these models?

Caching changes the ranking for agent loops and long system prompts. From the pricing page: 30-minute cache writes cost 1.25x the input price and 12-hour writes cost 2.5x. For Sol that is $2.50 and $5.00 per 1M; for Terra $1.25 and $2.50. Cached reads are $0.10 per 1M on Sol and $0.05 on Terra.

A rough break-even: a 12-hour write on Sol costs $5.00 per 1M tokens against $2.00 for sending the same tokens uncached, so you pay a $3.00 premium per 1M once. Each later cache hit saves $1.90 per 1M ($2.00 minus $0.10). By that arithmetic the premium is repaid after two hits on the same prefix, if hits land within the window. That ignores everything about how often your prefix really repeats, so measure your hit rate before choosing the longer window. See prompt caching across Anthropic and OpenAI for the mechanics; its figures predate the October 20 change.

What I could not verify

• Any benchmark or quality comparison between the four models. OpenAI's pages I read give descriptions, not scores, and I did not copy any from elsewhere.
• Whether gpt-6-sol is retiring.
• Terra's exact effort list (the two page fetches differed).
• Latency, real pass rates and Ultrafast speed-ups: not measured.
• Pages were read through a summarising fetch tool and re-queried for the specific numbers. Prices can change; confirm before you budget.

Sources, read 2026-10-30: OpenAI models, GPT-6.1 Terra model page, OpenAI pricing, OpenAI API changelog. For the October context on other vendors, see the October model API changes digest.