GPT 5.6 Terra: Price, Sol vs Luna and API Code (2026)

GPT 5.6 Terra is the middle tier of OpenAI’s GPT-5.6 family. It costs far less than the flagship Sol and does more than the budget Luna, which makes it the tier most teams should try first for coding help, document work, analysis and agent loops. This guide covers how Terra relates to the other two tiers, what a real request costs, the code to call it, and the mistakes that waste money or quietly hurt quality.

What is GPT 5.6 Terra?

OpenAI released GPT-5.6 on July 9, 2026. Earlier generations shipped as one model with “mini” and “nano” variants. GPT-5.6 instead comes as three named tiers:

• GPT 5.6 Sol: the flagship and the most expensive tier, meant for the hardest reasoning work.
• GPT 5.6 Terra: the balanced tier, for everyday professional work at a moderate price.
• GPT 5.6 Luna: the low-cost tier, for simple, high-volume tasks.

A “tier” here means a model at a fixed point on the trade-off between capability and price. All three share the same API surface. On Unicorn API each tier has its own model id (gpt-5-6-sol, gpt-5-6-terra, gpt-5-6-luna), and each has been available since July 10, 2026. All three accept the same request fields: messages, tools, tool_choice, stream, max_tokens, temperature, top_p, stop, response_format and reasoning_effort.

That shared surface is the practical point. Moving a workload from GPT 5.6 Terra to Sol or Luna means changing one string, not rewriting the integration. That makes it cheap to test which tier a task actually needs.

The names confuse people, and the confusion shows up in forums. Sol, Terra and Luna are tiers of the same release, not separate generations. A “5.6 Sol” and a “5.6 Terra” are siblings. Neither is a newer or older version of the other.

GPT-5.6 Sol vs Terra vs Luna: which tier should you use?

The price gaps between the tiers are large and regular, so the decision usually comes down to price first and capability second. These are the Unicorn API rates, in credits per one million tokens:

Tier	Input	Output	Cached input	Cache write	Cost vs Terra
GPT 5.6 Sol	280	1,680	28	350	2.5x
GPT 5.6 Terra	112	672	11.2	140	1x
GPT 5.6 Luna	11.2	67.2	1.12	14	0.1x

Sol costs exactly 2.5 times Terra on every line, and Luna costs exactly one tenth. So one Sol call costs about the same as 2.5 Terra calls or 25 Luna calls. Keep that ratio in mind whenever someone suggests “just use the best model”.

When Terra is the right call

• Coding assistance: explaining unfamiliar code, writing functions, reviewing pull requests, drafting tests.
• Document workflows: summarising reports, extracting fields, rewriting for a different audience.
• Agent loops with tool calls, where the model plans a few steps and calls your functions.
• Customer-facing chat where answers need to be accurate but the questions are not research problems.

When to move up to Sol

Escalate when Terra keeps failing the same task: multi-file refactors where it loses track of constraints, subtle bugs it cannot find after a couple of attempts, or long chains of reasoning where one wrong step ruins the answer. A common pattern is “Terra first, Sol on retry”. Most requests stay cheap, and the hard ones still get solved.

When to drop down to Luna

Classification, tagging, short rewrites, routing decisions (“is this a billing question or a bug report?”) and other narrow, repetitive work rarely need Terra. At one tenth of the price, Luna is the right tier for anything you run thousands of times a day where a small error rate is acceptable or easy to catch.

GPT 5.6 Terra pricing, worked out in credits

Chat models are billed per token. A token is a chunk of text, roughly three quarters of an English word on average. You pay separately for input tokens (everything you send: system prompt, conversation history, documents, tool definitions) and output tokens (everything the model writes back). On Unicorn API the exact charge comes from the token usage the model reports, so you pay for what the request actually used.

Credits cost $0.01 each on monthly plans (Starter $25, Creator $50, Studio $100, Pro $200 per month). Top-ups cost $0.015 per credit and never expire. At plan rates, GPT 5.6 Terra works out to $1.12 per million input tokens and $6.72 per million output tokens. Plan details are on the pricing page.

A worked example

Take a typical coding-assistant request: a 4,000-token prompt (system instructions, a file and a question) and an 800-token answer.

• Input: 4,000 × 112 / 1,000,000 = 0.448 credits
• Output: 800 × 672 / 1,000,000 = 0.5376 credits
• Total: about 0.99 credits, roughly one cent on a plan

Scaled to 1,000 such requests, the three tiers compare like this:

Tier	Credits per request	Credits per 1,000 requests	Plan cost per 1,000
Sol	2.46	2,464	$24.64
Terra	0.99	986	$9.86
Luna	0.10	99	$0.99

Look at the split: output was only 800 of 4,800 tokens but more than half the cost. Output tokens cost six times as much as input tokens on every GPT-5.6 tier, so verbose answers are the first thing to trim.

How prompt caching changes the maths

Prompt caching means the provider stores a prompt prefix it has already processed, such as a long system prompt or a reference document, so later requests that start with the same prefix are billed at a lower “cached input” rate. For Terra that rate is 11.2 credits per million, one tenth of normal input. Writing a prefix to the cache is billed at 140 credits per million, a little more than normal input.

In the example above, suppose 3,000 of the 4,000 input tokens are a fixed system prompt that hits the cache. The input cost falls from 0.448 to 0.146 credits (3,000 cached at 11.2 plus 1,000 fresh at 112). The total drops from about 0.99 to about 0.68 credits, roughly 30% less, with no change to the output. To get those hits, put the stable content first and the changing content last.

If you want the exact figure before you send anything, POST /v1/models/price returns the price of a request ahead of time. The API documentation shows the request shape.

How to call GPT 5.6 Terra through the API

Unicorn API exposes chat models through an OpenAI-compatible endpoint, POST /v1/chat/completions. If you have code that talks to OpenAI’s chat API, you change the base URL, the key and the model id.

1. Create a key on the API keys page and export it as UNICORN_API_KEY.
2. Optionally, try prompts in the browser playground first to compare Terra with Sol and Luna side by side.
3. Send a request with "model": "gpt-5-6-terra".

curl

curl https://api.unicornapi.net/v1/chat/completions \
  -H "Authorization: Bearer $UNICORN_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5-6-terra",
    "messages": [
      {"role": "system", "content": "You are a concise senior Python reviewer."},
      {"role": "user", "content": "Review this function for bugs:\n\ndef avg(xs):\n    return sum(xs) / len(xs)"}
    ],
    "max_tokens": 400
  }'

Python, with a cost check from the usage block

This version reads the token usage from the response and converts it to credits using Terra’s rates. That is handy for logging spend per feature.

import os
import requests

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

# Credits per 1M tokens (input, output)
RATES = {
    "gpt-5-6-sol":   (280, 1680),
    "gpt-5-6-terra": (112, 672),
    "gpt-5-6-luna":  (11.2, 67.2),
}

def chat(model, messages, max_tokens=500):
    resp = requests.post(API, headers=HEADERS, json={
        "model": model,
        "messages": messages,
        "max_tokens": max_tokens,
    }, timeout=120)
    resp.raise_for_status()
    data = resp.json()
    usage = data.get("usage", {})
    rate_in, rate_out = RATES[model]
    # Rough estimate: ignores any cached-input discount
    credits = (usage.get("prompt_tokens", 0) * rate_in
               + usage.get("completion_tokens", 0) * rate_out) / 1_000_000
    return data["choices"][0]["message"]["content"], credits

answer, cost = chat("gpt-5-6-terra", [
    {"role": "user", "content": "Explain Python's GIL in three sentences."}
])
print(answer)
print(f"~{cost:.4f} credits")

Python with the OpenAI SDK

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.unicornapi.net/v1",
    api_key=os.environ["UNICORN_API_KEY"],
)

reply = client.chat.completions.create(
    model="gpt-5-6-terra",
    messages=[{"role": "user", "content": "Write a regex that matches ISO dates."}],
    max_tokens=300,
)
print(reply.choices[0].message.content)

JavaScript with streaming

Streaming ("stream": true) sends the answer token by token, so chat interfaces feel responsive. It does not change the price.

const res = await fetch("https://api.unicornapi.net/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.UNICORN_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "gpt-5-6-terra",
    stream: true,
    max_tokens: 500,
    messages: [{ role: "user", content: "Outline a migration plan from REST to GraphQL." }],
  }),
});

const reader = res.body.getReader();
const decoder = new TextDecoder();
let buffer = "";
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  buffer += decoder.decode(value, { stream: true });
  const lines = buffer.split("\n");
  buffer = lines.pop();
  for (const line of lines) {
    if (!line.startsWith("data: ")) continue;
    const payload = line.slice(6).trim();
    if (payload === "[DONE]") continue;
    const delta = JSON.parse(payload).choices?.[0]?.delta?.content;
    if (delta) process.stdout.write(delta);
  }
}

If you work inside Cursor, Claude Code or another coding agent, you can reach the same models through MCP. The agents page explains the setup.

Tool calling, JSON output and reasoning effort

Three request fields do most of the work in production apps built on GPT 5.6 Terra.

Tool calling

Tool calling lets the model ask your code to run a function, such as looking up an order or querying a database, and then use the result in its answer. You describe each tool with a JSON schema in tools. The model returns a tool_calls entry instead of text when it wants one. You run the function, append the result as a tool message, and call the API again.

{
  "model": "gpt-5-6-terra",
  "messages": [{"role": "user", "content": "What's the status of order 8812?"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_order_status",
      "description": "Look up an order by id",
      "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"]
      }
    }
  }],
  "tool_choice": "auto",
  "max_tokens": 300
}

Tool definitions count as input tokens on every turn. A large toolset with long descriptions can cost more than the conversation itself, so keep the schemas tight. Because they sit at the start of the prompt and rarely change, they are also good candidates for caching.

Structured output

response_format asks the model to reply in JSON, which saves you from parsing prose. Use it for extraction jobs such as pulling invoice fields or turning a support email into a ticket. Validate the result in your code anyway, and give the model a short example of the shape you expect.

Reasoning effort

reasoning_effort controls how much the model thinks before answering. More effort usually helps on hard problems, but it produces more tokens and adds latency. Reasoning tokens count toward usage, so they cost credits. The accepted values are listed in the docs. A useful habit: before you escalate from Terra to Sol, try Terra at a higher effort. Sometimes that closes the gap for less than the 2.5x jump.

How GPT 5.6 Terra compares with other chat models

Terra is not the only model in its price range. With one key, comparing it against alternatives is a matter of changing the model id. These are the rates on Unicorn API, in credits per million tokens:

Model	Input	Output	Cached input	Notes from the catalog
GPT 5.6 Terra	112	672	11.2	Balanced GPT-5.6 tier
Wish 1.0	120	480	2.4	One-million-token context, image input, tool calling, four reasoning levels
Gemini 4 Argon	160	800	n/a	Google’s model
DeepSeek V4.1 Flash FP8	28	84	0.84	Fast, one-million-token context, closer to full precision
DeepSeek V4.1 Flash FP4	12	24	0.32	Same model at FP4, lowest price

A few things stand out:

• Wish 1.0 charges slightly more for input and noticeably less for output (480 vs 672). For output-heavy work like long code generation, it can come out cheaper than Terra. Note that the model behind Wish is chosen and updated over time, and the provider serving it may use prompts and replies to improve its models. That matters if you handle sensitive data.
• Gemini 4 Argon costs more than Terra on both input and output. It is worth testing if you prefer Google’s models. Our Gemini 4 Argon guide covers it in detail.
• DeepSeek V4.1 Flash is in a different price class. FP8 and FP4 refer to numeric precision: lower precision is cheaper to serve but can lose some quality. For bulk work it competes more with Luna than with Terra.

Prices tell you cost, not quality. The only reliable comparison is your own: take 20 to 50 real prompts from your app, run them through two or three models, and grade the answers. The full model catalog lists everything you can test with the same key.

Common mistakes with GPT 5.6 Terra

1. Defaulting everything to Sol. Sol costs 2.5x Terra on every token. Unless you have measured that Terra fails a task, start with Terra and escalate only the requests that need it.
2. Using Terra for trivial work. Classification, routing and short rewrites usually run fine on Luna at one tenth of the price. A cheap first pass that sends only the hard cases to GPT 5.6 Terra is often the biggest single saving.
3. Not setting max_tokens. Output is the expensive side. A cap prevents runaway answers, and an instruction like “answer in under 150 words” cuts cost more than any model switch.
4. Breaking the cache. Putting a timestamp or user id at the top of the system prompt changes the prefix on every request, so nothing is ever cached. Keep stable content first.
5. Resending whole conversations forever. Every turn resends the history as input. Summarise or trim old turns in long chats.
6. Confusing the tier names with versions. GPT 5.6 Terra is not “older Sol”. When you read benchmark claims or forum posts, check which tier and which version they mean.
7. Hard-coding one model. Put the model id in config. Then moving a feature between Sol, Terra, Luna or a non-OpenAI model is a deploy, not a refactor.

A simple router puts most of these lessons into practice:

def pick_model(task_type, retries=0):
    if task_type in {"classify", "tag", "route"}:
        return "gpt-5-6-luna"
    if retries >= 2:
        return "gpt-5-6-sol"      # escalate only after Terra fails twice
    return "gpt-5-6-terra"        # sensible default

Start there, log the credits each route spends using the usage block shown earlier, and adjust the thresholds once you have real data. For most teams, GPT 5.6 Terra ends up carrying the bulk of the traffic, with Sol and Luna covering the two ends.