OpenAI’s GPT-5.6 Luna API is the economy tier of the GPT-5.6 family — the same reasoning engine the flagship ships, at $0.20 per million input tokens and $1.20 per million output after the vendor’s price cut — and it speaks the OpenAI-SDK compatible dialect, so an existing codebase needs only a base URL, a key and a model string to make its first call. It is available from OpenAI’s own API and several third-party platforms; the examples below use OrcaRouter’s endpoint, which passes the post-cut price through at 0% markup and keeps the whole family behind one key. This tutorial covers the full surface — model IDs, the reasoning-effort parameter, a minimal call, streaming and the tier decision — and if you would rather read the price math first, GPT-5.6 Luna carries the live rate card for the tier.
The tutorial itself is short, because the integration genuinely is: nothing below is exotic, and a first response takes minutes. The decisions are where the time goes — which tier to call for which workload, how much reasoning effort to pay for, and what latency to plan around. The second half of this piece is about those three.
The surface you already know
The GPT-5.6 family exposes the standard OpenAI chat-completions surface: a chat.completions.create call, a messages array and a model string. On OrcaRouter the economy tier’s ID is openai/gpt-5.6-luna; Sol and Terra sit under the same family convention (openai/gpt-5.6-sol, openai/gpt-5.6-terra), so moving between tiers is a string change, not a refactor. Luna’s context window is 1,000,000 tokens — an independent measurement from Artificial Analysis — which is enough to hand the model a large repository in one call.
The minimal call, in Python with the standard OpenAI SDK:
“`python
from openai import OpenAI
client = OpenAI(
base_url=”https://api.orcarouter.ai/v1″,
api_key=”YOUR_ORCAROUTER_KEY”,
)
resp = client.chat.completions.create(
model=”openai/gpt-5.6-luna”,
messages=[
{“role”: “user”, “content”: “Summarize this spec in three bullets.”},
],
)
print(resp.choices[0].message.content)
“`
That is the whole integration. The response shape is standard too — choices[0].message.content holds the answer — and usage reports prompt, completion and, because this model reasons, thinking tokens. That last number is where the cost surprises live, and we will come back to it.
Streaming, because reasoning is visible work
A reasoning model thinks before it writes the visible answer, so the first token takes a moment. With stream=True you keep the connection open and render tokens as they arrive, which turns a “is it stuck?” wait into a visible, working progress. The streaming call is the minimal call plus one argument:
“`python
stream = client.chat.completions.create(
model=”openai/gpt-5.6-luna”,
messages=[{“role”: “user”, “content”: “Draft a changelog for this release.”}],
stream=True,
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end=””, flush=True)
“`
Luna is fast enough that streaming matters slightly less than it does on a slower flagship: Artificial Analysis measures a median output speed of 156.6 tokens per second — among the fastest on its board, where the flagship Sol records 73.7 — and flags the model as “notably fast”. For any user-facing feature, stream anyway.
The reasoning-effort dial
Every GPT-5.6 model reasons; you cannot turn it off, but you can choose how hard. Effort runs from medium up through high and xhigh to max, and the scores everyone quotes are the max configuration. Artificial Analysis records an Intelligence Index of 52.32 for Luna at max effort, dropping to 50.06 at xhigh and 46.96 at high. Compare max to max, never to the default — otherwise you are benchmarking a different model.
The dial matters because reasoning tokens bill as output tokens. Artificial Analysis’ cost to evaluate Luna on its full Intelligence Index is $172.17, on 130 million output tokens against a 60-million median for the tier — a model that thinks harder spends more tokens before it answers. Keep the dial low for extraction, classification and routing; raise it for genuinely hard analysis, and measure the quality gain on your own tasks before you pay for it.
Which tier should you call?
The GPT-5.6 family is one endpoint with three price points. Prices below are the post-cut figures on OrcaRouter’s catalog; Intelligence Index scores are Artificial Analysis’ independent max-effort measurements.
| Tier | Model ID | Price per 1M tokens (after the cut) | Intelligence Index (max) | What it is for |
| Sol | openai/gpt-5.6-sol | $5 in / $30 out (unchanged) | 60.93 | the hardest reasoning |
| Terra | openai/gpt-5.6-terra | $2 in / $12 out (from $2.50 / $15) | 56.58 | the balanced default |
| Luna | openai/gpt-5.6-luna | $0.20 in / $1.20 out (from $1 / $6) | 52.32 | high volume |
Luna is built to be the volume workhorse. It carries by far the most traffic in OrcaRouter’s seven-day telemetry at 21,271.6M tokens, and Replit’s free tier now runs on it — a real-world sign that it holds up under load. The price gap is the headline: at $0.05 per Intelligence Index task on Artificial Analysis’ board — the cheapest figure there, against Sol’s $1.23 — Luna makes running evaluations on your own data cheap enough to do properly.
A simple policy: start on Luna and measure. Escalate to Terra when quality is close but not quite there, and to Sol when the problem is genuinely the hardest kind. One caveat — pricing varies by listing; a single outside source quotes different figures for very high prompt volumes — so our reference throughout is the post-cut price, passed through at 0% markup.
Cost controls and latency expectations
The post-cut price of $0.20 in / $1.20 out is roughly an 80% cut from the launch price of $1 in / $6 out, per OrcaRouter’s catalog. Three controls dominate the bill: the tier you call, the effort dial, and your prompt size inside that 1M context. A token is a token whether it is a prompt token, a thinking token or an answer token — Luna just happens to price all of them lower than the rest of the family.
On latency, expect two different numbers, and both are correct. Artificial Analysis’ controlled runs measure about 102 ms to first token — genuinely fast. OrcaRouter’s own seven-day production telemetry shows a p50 time-to-first-token of 1.33 seconds and a p95 of 7.32 seconds across real traffic. The benchmark measures an idle model; production measures routing, contention and cold queues. For a reference point, Claude Opus 5 on the same infrastructure window runs a 7.34-second p50 — Luna reaches its first token about five times faster, which is what a volume tier should do.
All of that runs behind one key on OrcaRouter at 0% markup — the price in the catalog is the price you pay — with automatic failover if the underlying provider has a bad afternoon. The key that calls Luna also calls Sol and Terra, so the tier decision never requires a second integration.
The takeaway
Start on Luna. At $0.20 in / $1.20 out it is the cheapest reasoning available per unit of Intelligence Index, and the production picture — 21,271.6M tokens a week and a 1.33-second p50 first token on OrcaRouter’s telemetry — says it is built for real load. Raise effort deliberately instead of inheriting the default, compare your results to the max-effort benchmarks fairly, and only climb to Terra at $2 / $12 or Sol at $5 / $30 when your own evaluations show the cheaper model losing. Luna is not the right call when you need the very top of the family’s benchmark table — Sol’s 60.93 leads Luna’s 52.32 by about 8.6 points — but for high-volume reasoning, the answer is one endpoint, three prices, and Luna is where you start.
Sourcing note: pricing, the ~80% price cut and the family tier figures are OrcaRouter’s catalog data, which passes vendor list prices through at 0% markup. Intelligence Index, output speed, first-token, per-task cost and token-consumption figures are Artificial Analysis’ independent measurements. p50 and p95 time-to-first-token and seven-day traffic volumes are OrcaRouter’s own production telemetry. Checked August 22, 2026.