Using GPT 5.6 Luna: Credit Pricing and Code (2026)

GPT 5.6 Luna is the smallest and cheapest of the three models in OpenAI’s GPT-5.6 family, sitting below Terra and Sol. That one line explains most of what people want from it: it is the model you reach for when a job runs ten thousand times a day and the per-request cost matters more than the last few points of benchmark score. On Unicorn API it costs 22.4 credits per million input tokens and 134.4 credits per million output tokens, which works out to roughly a quarter of a cent per million words of input on a monthly plan.

This post covers what GPT 5.6 Luna is designed for, exactly what it costs in credits and dollars, how it compares to its siblings and to small models from Anthropic and Google, and how to call it with real code. There is also a worked cost calculation for a 100,000-request batch, because that is the number most people are actually trying to work out.

What is GPT 5.6 Luna?

GPT 5.6 Luna is a chat model from OpenAI, released on 10 July 2026 alongside GPT 5.6 Sol and GPT 5.6 Terra. All three are the same family trained for the same behaviours, offered at three different sizes and prices. Luna occupies the slot that earlier OpenAI families called “nano” or “mini”: a model small enough to answer in well under a second on short prompts, and cheap enough that you stop thinking about cost per call.

A few terms worth pinning down before the pricing section, since they drive the bill:

• Token: the unit models read and write, roughly three quarters of an English word. Pricing is quoted per million tokens, split between input (what you send) and output (what the model writes back).
• Cached input: when you send the same prefix repeatedly, for example a long system prompt, the provider can reuse the processed version of it at a large discount instead of charging full input price.
• Reasoning effort: a dial that lets the model think for longer before answering. The thinking is billed as output tokens, so raising it raises the cost of the call.

Luna accepts the same request fields as the rest of the family: model, messages, tools, tool_choice, stream, max_tokens, temperature, top_p, stop, response_format and reasoning_effort. That matters more than it sounds. Because tool calling and structured JSON output are available on the cheap tier, you can build the whole pipeline against Luna and only swap the model id where quality demands it.

GPT 5.6 Luna pricing in credits and dollars

Unicorn API prices everything in credits, so one key and one bill cover chat, image, video and audio models. Here is the full price list for GPT 5.6 Luna:

Token type	Credits per 1M tokens	Plan credits ($0.01 each)	Top-up credits ($0.015 each)
Input	22.4	$0.224	$0.336
Output	134.4	$1.344	$2.016
Cached input	2.24	$0.0224	$0.0336
Cache write	28	$0.28	$0.42

Monthly plans buy credits at one cent each: Starter is $25, Creator $50, Studio $100 and Pro $200 per month, all on the pricing page. Top-up credits cost $0.015 and never expire, which makes them the sane choice for spiky workloads where a monthly commitment would go unused.

Three details in that table are worth acting on. Output tokens cost six times input tokens, so verbosity is the main cost lever you control. Cached input is one tenth of normal input, so a stable system prompt reused across a batch is nearly free after the first call. And a cache write costs more than a plain input token, so caching only pays off if you are going to reuse the prefix several times.

You never have to estimate blind. POST /v1/models/price returns the exact price of a request before you run it, which is the right thing to call in a staging environment when you are sizing a batch job:

curl https://api.unicornapi.net/v1/models/price \
  -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
  }'

Billing then follows the usage the model actually reports, so a request that stops early costs less than the quote. The API documentation has the full response shape.

Sol vs Terra vs Luna: which GPT-5.6 tier to use

The three tiers share an API and differ by a factor of ten at each step. Input and output prices scale together, so the ratios hold whatever your prompt looks like:

Model	Input (credits / 1M)	Output (credits / 1M)	Cached input	Relative token cost
GPT 5.6 Luna	22.4	134.4	2.24	1x
GPT 5.6 Terra	224	1344	22.4	10x
GPT 5.6 Sol	560	3360	56	25x

A practical way to choose: ask what a wrong answer costs you. If a mislabelled support ticket just lands in a slightly wrong queue and a human fixes it in five seconds, Luna is the right call and the money saved is real. If a wrong answer ships to a customer, triggers a payment, or writes code that nobody reviews, pay for Terra or Sol on that path. The second question is how long the chain of reasoning is. Luna is strong on single-step tasks with clear instructions and degrades faster than its siblings as a task grows to five or six dependent steps. Terra is the usual middle ground: ten times the token price, noticeably more headroom on multi-step work. Sol is the tier you reserve for the hardest requests, and there is a separate write-up on Sol pricing and access if that is where you are heading. The newer family is covered in the GPT 6 models and pricing post.

How it compares to other small models

Luna is not the only cheap, fast chat model worth testing. Claude Haiku 5.5 is priced within a hair of it at 24 credits per million input tokens and 120 per million output, which makes output slightly cheaper and input slightly more expensive. If your workload is output-heavy, that difference is worth measuring. One step up, Gemini 4 Argon and Claude Sonnet 5.5 both sit at 320 input and 1600 output, between Terra and Sol. Google also ships an OpenAI-compatible variant as Gemini 4 Argon OpenAI if you want to keep a single client library across vendors. Because every one of these runs through the same endpoint and the same key, a bake-off is a loop over model ids rather than three separate accounts; the full list is in the model catalog.

How to call GPT 5.6 Luna from the API

GPT 5.6 Luna is a chat model, so it uses the OpenAI-compatible endpoint POST /v1/chat/completions. Create a key at /keys, export it as UNICORN_API_KEY, and the smallest possible call looks like this:

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
  }'

The response carries the text in choices[0].message.content and the token counts in usage. Those counts are what you bill against, so it is worth printing them while you are developing. In Python, point the official OpenAI client at the Unicorn base URL and nothing else changes:

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="gpt-5-6-luna",
    messages=[
        {"role": "system", "content": "Answer in one short sentence."},
        {"role": "user", "content": "Write one sentence about unicorns."},
    ],
    max_tokens=200,
    temperature=0.7,
)

print(resp.choices[0].message.content)

usage = resp.usage
credits = (
    usage.prompt_tokens / 1_000_000 * 22.4
    + usage.completion_tokens / 1_000_000 * 134.4
)
print(f"{usage.prompt_tokens} in, {usage.completion_tokens} out, {credits:.5f} credits")

Set stream: true when a human is waiting for the text, since Luna’s speed is most of its appeal and streaming makes it feel immediate. If you would rather poke at prompts before writing any code, the browser playground runs the same models, and the MCP integration exposes them inside Cursor or Claude Code.

A worked example: 100,000 classifications

Here is the arithmetic that decides whether a project is viable. Say you are classifying 100,000 support tickets. Each request sends a 500-token instruction block plus a 100-token ticket, and the model returns about 80 tokens of JSON.

• Input: 600 tokens x 100,000 = 60M tokens. At 22.4 credits per million, that is 1,344 credits.
• Output: 80 tokens x 100,000 = 8M tokens. At 134.4 credits per million, that is 1,075.2 credits.
• Total: 2,419.2 credits, or about $24.19 of plan credits.

The same batch on Terra costs roughly 24,192 credits ($241.92) and on Sol roughly 60,480 credits ($604.80). That is the whole argument for the small tier in one line: a job that fits inside a $25 Starter plan on GPT 5.6 Luna needs a $200 Pro plan three times over on the frontier tier.

Caching sharpens it further. If that 500-token instruction block is identical across all 100,000 calls and gets cached, the repeated portion drops from 22.4 to 2.24 credits per million, pulling the input side from 1,344 credits down towards 220 and the total to roughly 1,300 credits. Verify the behaviour against your own traffic rather than assuming it, but the direction is reliable: stable prefixes are the cheapest tokens you will ever send.

Routing: Luna first, escalate when unsure

The pattern that gets the most out of a cheap model is to let it handle the easy majority and pass the rest upward. Ask for a confidence score, then re-run only the low-confidence cases on Terra:

const BASE = "https://api.unicornapi.net/v1";

async function chat(model, messages, extra = {}) {
  const res = await fetch(`${BASE}/chat/completions`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.UNICORN_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ model, messages, max_tokens: 300, ...extra }),
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.json();
}

const SYSTEM = `Classify the support ticket. Reply with JSON only:
{"category": "billing" | "bug" | "feature" | "other", "confidence": 0-1}`;

async function classify(ticket) {
  const messages = [
    { role: "system", content: SYSTEM },
    { role: "user", content: ticket },
  ];
  const opts = { response_format: { type: "json_object" }, temperature: 0 };

  const cheap = await chat("gpt-5-6-luna", messages, opts);
  const first = JSON.parse(cheap.choices[0].message.content);
  if (first.confidence >= 0.75) return { ...first, model: "gpt-5-6-luna" };

  const better = await chat("gpt-5-6-terra", messages, opts);
  return { ...JSON.parse(better.choices[0].message.content), model: "gpt-5-6-terra" };
}

console.log(await classify("I was charged twice for September."));

If 85% of tickets clear the confidence bar, the blended cost is about 0.85 Luna calls plus 0.15 Terra calls, which lands near one fifth of an all-Terra bill while keeping Terra’s accuracy on the hard tail. Log which model answered so you can tune the threshold with real numbers instead of a guess.

What GPT 5.6 Luna is not good at

Being honest about the ceiling saves you a week of debugging. GPT 5.6 Luna is weakest in four places:

• Long dependent reasoning. Tasks where step four depends on getting steps one to three right, like multi-table SQL over an unfamiliar schema, or working out a refund across overlapping policies.
• Large codebase work. It is fine for a self-contained function, a regex, a commit message or a test stub. Cross-file refactors and subtle bug hunts belong on Terra or Sol.
• Long agent loops. Small models drift over many tool calls: repeating an action, forgetting an earlier constraint, or declaring success early. Keep agent chains short, or use the cheap tier only for individual well-scoped sub-steps.
• Thin instructions. A bigger model will often guess what you meant. Luna does what you wrote. Spell out the categories, the edge cases and the output format.

Raising reasoning_effort recovers some of the gap on medium-difficulty tasks, but it is not free: the extra thinking is billed as output tokens at 134.4 credits per million, and enough of it erases the price advantage that made you pick the tier. Measure before you turn it up everywhere.

Mistakes people make with GPT 5.6 Luna

These are the recurring ones, in rough order of how much money they waste.

1. Judging it on the wrong task. People test GPT 5.6 Luna on a hard reasoning puzzle, watch it fail, and write the model off. Then they also stop using it for the ticket classification where it would have been 98% accurate at a twenty-fifth of the price. Evaluate per task, not in general.
2. No eval set. Pick 200 real examples with known answers and run them through Luna and Terra. You then have an accuracy number against a price number instead of a vibe. This takes an afternoon and routinely settles the question.
3. Letting output run long. Output is six times the price of input here, so “be concise” in the system prompt and a sensible max_tokens cut bills more than any other tweak. Ask for a label, not a paragraph explaining the label.
4. Parsing prose instead of JSON. Use response_format and temperature: 0 for machine-read output. Regexing English out of a small model’s reply is where most flaky pipelines come from.
5. Rewriting the prompt for every tier. Because Sol, Terra and Luna share the request shape, keep one prompt and switch the model id. If a prompt only works on one tier, it is probably underspecified.
6. Caching the wrong thing. A cache write costs 28 credits per million, above the 22.4 plain input price. Caching a prefix you use twice loses money; caching one you use ten thousand times is close to free.
7. Guessing the cost. Call POST /v1/models/price on a representative request, multiply by your volume, and compare that to a plan on the pricing page before committing to a batch.

Getting started

The fastest route is to take one task you already run at volume, put GPT 5.6 Luna behind it, and keep a log of model, tokens and whether the answer was right. Create a key at /keys, copy the curl call above, change the prompt to your real prompt, and read the usage block on the way back.

If the accuracy holds, the savings are large and immediate. If it does not, you change one string to gpt-5-6-terra and keep going. That is the real value of a cheap tier that shares its API with its bigger siblings: trying it costs almost nothing, and the fallback is a one-line edit rather than a rewrite.