GPT-5.6 Sol, Terra, Luna: Pricing, Use Cases and API (2026)

The GPT 5.6 Sol Terra Luna lineup is the three-tier model line OpenAI shipped in place of a single GPT-5.6 model. The names follow a size order you can remember: Sol (the sun) is the largest and most capable, Terra (the earth) is the everyday workhorse, and Luna (the moon) is the smallest and cheapest. The useful question is not which one is “best”. It is which tier each of your requests deserves, because the price gap between them is large.

This guide explains what each tier is for, how the three are priced in credits on Unicorn API, what a real workload costs, how to call them from code, and how they compare with Fable 5 and newer models.

GPT 5.6 Sol Terra Luna: what the three tiers are

All three models share the same family, the same request format and the same feature set. They differ in capability, speed and price. Think of them as one model offered at three sizes.

• GPT 5.6 Sol is the flagship. Use it for the hardest problems: large refactors, subtle debugging, long agent runs where one wrong step wastes the whole run, and reasoning-heavy analysis.
• GPT 5.6 Terra is the workhorse. It handles most coding, writing, tool calling and agent tasks well, at 2.5x lower per-token cost than Sol.
• GPT 5.6 Luna is the budget tier. It is built for volume: classification, extraction, routing, short answers, summaries and simple chat. It costs a tenth of Terra per token.

Because every model in the GPT 5.6 Sol Terra Luna family accepts identical request fields, switching tiers is a one-word change to the model parameter. That is what makes the three-tier design practical: you can route each request to the cheapest tier that does the job well, and escalate only when you need to.

Two terms come up repeatedly below. A token is a chunk of text, roughly three quarters of an English word on average; models are billed per million tokens read (input) and written (output). Reasoning effort is a setting that tells the model how much internal thinking to do before answering. More thinking usually means better answers on hard problems, but also more output tokens and a slower reply.

GPT-5.6 release date and availability

OpenAI first previewed GPT-5.6 as a three-model line, then made Sol, Terra and Luna widely available in early July 2026. On Unicorn API, all three went live on July 10, 2026, under these ids:

• gpt-5-6-sol
• gpt-5-6-terra
• gpt-5-6-luna

Unlike some earlier launches, the GPT 5.6 Sol Terra Luna release did not stagger the tiers: all three arrived together. That matters if you are planning a routing setup, because you can build and test the whole ladder at once.

OpenAI has kept shipping since then. GPT 6.1 Terra arrived on Unicorn API on October 28, 2026, and it is worth a look if you are choosing a Terra-class model today (more on that below). You can try any of these models in the browser playground before writing code.

Sol vs Terra vs Luna: side-by-side comparison

Here is how the GPT 5.6 Sol Terra Luna tiers line up on Unicorn API. Prices are in credits per one million tokens. On a monthly plan a credit costs $0.01; top-up credits cost $0.015 and never expire.

	GPT 5.6 Luna	GPT 5.6 Terra	GPT 5.6 Sol
Role	Cheap, high volume	Everyday workhorse	Flagship, hardest tasks
Input (per 1M)	11.2 credits	112 credits	280 credits
Output (per 1M)	67.2 credits	672 credits	1,680 credits
Cached input (per 1M)	1.12 credits	11.2 credits	28 credits
Cache write (per 1M)	14 credits	140 credits	350 credits
Relative cost per token	1x	10x	25x
Tools, streaming, JSON output	Yes	Yes	Yes
temperature, top_p, reasoning_effort	Yes	Yes	Yes
Best for	Classification, extraction, summaries, simple chat	Coding, writing, tool calling, most agents	Large refactors, deep debugging, long agent runs

On quality, the benchmark comparisons published at launch put Sol above Anthropic’s Fable 5, Terra just above Fable 5, and Luna ahead of Claude Opus 4.8. In plain terms: even the cheapest GPT-5.6 tier is strong, and the gap between Terra and Sol is narrower than the 2.5x price gap suggests for many everyday tasks.

Which model is better, GPT-5.6 Terra or Luna?

Terra is more capable. It holds up better on multi-step instructions, longer code edits and agent loops with several tool calls. Luna wins on cost and is fast enough for interactive use. If a task has a clear, checkable answer (a label, a JSON object, a yes or no), start with Luna. If the task is open-ended or a mistake is expensive, start with Terra.

GPT-5.6 pricing on Unicorn API, with a worked example

Per-token prices are easy to read and hard to feel, so here are two realistic workloads priced across the whole GPT 5.6 Sol Terra Luna range.

Example 1: a support assistant

Each request sends about 2,000 input tokens (system prompt, a help-centre excerpt and the customer’s message) and gets back about 400 output tokens. You run 10,000 requests a month, so 20 million input tokens and 4 million output tokens in total.

Tier	Input credits	Output credits	Total credits	At $0.01/credit
Luna	224	268.8	492.8	about $4.93
Terra	2,240	2,688	4,928	about $49.28
Sol	5,600	6,720	12,320	about $123.20

The Luna workload fits inside the Starter plan ($25 a month for 2,500 credits) with room to spare. The Terra version fits in the Creator plan ($50). The Sol version needs the Pro plan ($200) or the Studio plan plus a top-up. Full plan details are on the pricing page.

Example 2: one coding agent turn, with and without caching

A coding agent sends a lot of context on every turn: the repository map, open files and conversation history. Say one turn is 40,000 input tokens and 2,000 output tokens.

• Sol: 40,000 input tokens cost 11.2 credits, 2,000 output tokens cost 3.36 credits, for 14.56 credits (about $0.15).
• Terra: 4.48 + 1.344 = 5.824 credits (about $0.06).
• Luna: 0.448 + 0.1344 = 0.5824 credits (under a cent).

Now add prompt caching. Caching means the provider stores a prefix of your prompt that repeats across requests, and later requests that reuse it are billed at the much lower cached-input rate. If 30,000 of those 40,000 tokens are a stable prefix that hits the cache, the Sol turn becomes 0.84 credits (cached) + 2.8 credits (uncached) + 3.36 credits (output) = 7.0 credits. That is less than half the uncached cost. Cached input is billed at a tenth of the normal input rate on every GPT 5.6 Sol Terra Luna tier, while the first write into the cache costs 1.25x the input rate, so caching pays off as soon as a prefix is reused even once.

You do not have to do this arithmetic by hand. Unicorn API returns the exact price of a request before you run it through POST /v1/models/price, and after the call, the cost is debited from the usage the model reports. The API documentation covers the price endpoint’s request format.

Which GPT-5.6 tier should you use for coding, agents and chat?

A simple rule works well for the GPT 5.6 Sol Terra Luna family: send each request to the cheapest tier you trust for it, and check the result where you can.

1. Default chat and lightweight tasks: Luna. Tagging tickets, pulling fields out of emails, writing product blurbs, summarising meeting notes, answering FAQ-style questions. These have short outputs and clear success criteria.
2. Most coding and agent work: Terra. Writing functions, fixing failing tests, answering questions about a codebase, multi-step tool use, drafting long documents.
3. High-stakes or stubborn problems: Sol. Cross-file refactors, bugs Terra could not fix, architecture reviews, long autonomous agent runs, and anything where a human will act on the answer without checking it closely.

The pattern that saves the most money is escalation: try Luna or Terra first, validate the output (does the JSON parse, do the tests pass, did the agent reach its goal), and retry on the next tier up only when the check fails. Because the tiers are 10x and 2.5x apart in price, an escalation that succeeds on the cheap tier most of the time costs far less than sending everything to Sol.

If you work inside Cursor, Claude Code or another coding agent, you can connect them to Unicorn API over MCP (Model Context Protocol, a standard way for agents to call external tools) and switch tiers per task. See the agents setup page.

How to call GPT-5.6 Sol, Terra and Luna from code

All three GPT 5.6 Sol Terra Luna models use the OpenAI-compatible chat completions endpoint. First, create an API key and export it as UNICORN_API_KEY.

A quick curl test

curl https://api.unicornapi.net/v1/chat/completions \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-6-luna",
    "messages": [{"role": "user", "content": "Write one sentence about unicorns."}],
    "max_tokens": 200
  }'

Change gpt-5-6-luna to gpt-5-6-terra or gpt-5-6-sol and nothing else needs to change.

A Python router with escalation and cost tracking

This script tries Luna first, checks that the reply is valid JSON with the fields it expects, and escalates to Terra and then Sol only when the check fails. It also estimates the credit cost of each call from the reported token usage, using the prices in the table above.

import json
import os

import requests

API_URL = "https://api.unicornapi.net/v1/chat/completions"
HEADERS = {
    "Authorization": f"Bearer {os.environ['UNICORN_API_KEY']}",
    "Content-Type": "application/json",
}

# Credits per 1M tokens on Unicorn API (input, output)
PRICES = {
    "gpt-5-6-luna": (11.2, 67.2),
    "gpt-5-6-terra": (112, 672),
    "gpt-5-6-sol": (280, 1680),
}
LADDER = ["gpt-5-6-luna", "gpt-5-6-terra", "gpt-5-6-sol"]


def chat(model, messages, max_tokens=800):
    body = {
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
        "temperature": 0.2,
        "response_format": {"type": "json_object"},
    }
    resp = requests.post(API_URL, headers=HEADERS, json=body, timeout=120)
    resp.raise_for_status()
    data = resp.json()
    usage = data.get("usage", {})
    price_in, price_out = PRICES[model]
    credits = (
        usage.get("prompt_tokens", 0) * price_in
        + usage.get("completion_tokens", 0) * price_out
    ) / 1_000_000
    return data["choices"][0]["message"]["content"], credits


def is_valid(reply):
    try:
        parsed = json.loads(reply)
    except json.JSONDecodeError:
        return False
    return {"category", "priority", "summary"} <= parsed.keys()


def classify_ticket(ticket_text):
    messages = [
        {
            "role": "system",
            "content": (
                "Classify the support ticket. Reply with JSON containing "
                "category, priority (low, medium or high) and a one-line summary."
            ),
        },
        {"role": "user", "content": ticket_text},
    ]
    total = 0.0
    for model in LADDER:
        reply, credits = chat(model, messages)
        total += credits
        if is_valid(reply):
            return json.loads(reply), model, total
    raise RuntimeError("No tier produced a valid answer")


if __name__ == "__main__":
    result, used, cost = classify_ticket(
        "I was charged twice for my October invoice and need a refund."
    )
    print(result)
    print(f"Answered by {used}, about {cost:.4f} credits")

A few notes on the request fields. temperature and top_p control randomness; low values give more consistent output, which is what you want for classification. response_format asks for JSON output. tools and tool_choice enable function calling for agents, and stream returns tokens as they are generated. reasoning_effort adjusts how much the model thinks before answering; the accepted values are listed in the docs. All of these work the same way on every GPT 5.6 Sol Terra Luna tier.

GPT-5.6 vs Fable 5 and other alternatives

Many searchers compare the GPT 5.6 Sol Terra Luna lineup with Anthropic’s Fable 5. Based on the benchmark results published at launch, Sol sits above Fable 5 and Terra roughly matches or slightly beats it. Benchmarks measure averages across fixed test sets, though, and your prompts are not those test sets. Treat them as a shortlist filter, then test on your own work.

Within the Unicorn API catalog, a few models are worth comparing against the GPT 5.6 Sol Terra Luna tiers:

Model	Input / output (credits per 1M)	Why consider it
GPT 6.1 Terra	60 / 300	Newer OpenAI Terra-class model, cheaper per token than GPT 5.6 Terra
Kimi K3.1 Pro	160 / 800	Moonshot’s latest model, released November 6, 2026
Wish 1.0	120 / 480	One-million-token context, image input, tool calling, four reasoning levels
DeepSeek V4.1 Flash FP4	12 / 24	Fast, very low output price, one-million-token context

The most interesting entry for GPT-5.6 Terra users is GPT 6.1 Terra: roughly half the input price and less than half the output price of GPT 5.6 Terra. If you are starting a new project today, test it alongside the GPT 5.6 Sol Terra Luna models. If you have a working GPT-5.6 setup with prompts you have already tuned, there is no urgency to switch; run your evaluation set through both and decide on the results. One caution on Wish 1.0: the model behind it is chosen and updated over time, and the provider serving it may use prompts and replies to improve its models, so check that fits your data policy. Browse everything in the full model catalog.

Common mistakes when choosing between Sol, Terra and Luna

• Sending everything to Sol. It feels safe, but at 25x Luna’s per-token cost, a workload that Luna or Terra could handle becomes expensive fast. Start one tier lower than your instinct says and measure.
• Judging tiers on one prompt. One good or bad answer tells you little. Build a small evaluation set of 20 to 50 real requests with known good answers and run all three tiers against it.
• Ignoring output tokens. Output costs 6x input on every GPT 5.6 Sol Terra Luna tier. Long answers and high reasoning effort add up. Set max_tokens and ask for concise responses where length does not add value.
• Breaking the cache. Caching only works when the start of the prompt is identical across requests. Put stable content (system prompt, documentation, tool definitions) first and variable content (the user’s message, timestamps) last.
• No validation step. Escalation only works if you can tell when a cheap tier failed. JSON schema checks, unit tests and simple rule checks turn a guess into a routing decision.
• Hard-coding one model id everywhere. Keep the model name in configuration so you can move a task between tiers, or to a newer model, without a code change.

The short version: GPT 5.6 Sol Terra Luna gives you one model family at three price points. Use Luna for volume, Terra for most real work, and Sol where quality matters more than cost. Because the request format never changes, the right setup is usually all three, wired into a router that picks the cheapest tier that passes your checks.