GPT-5.6 Luna is the fastest, most affordable member of OpenAI's GPT-5.6 family, described on its model page as designed for cost-sensitive, high-volume workloads such as summarization, drafting, and routine automation.
- Input
- text image $1/M
- Output
- text $6/M
- Cache read
- $0.1/M
- Context
- 1.1M
- vs GPT-4o
- ~80% cheaper
- Knowledge cutoff
- 2026-02
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Price in context
Where the price sits among 60 comparable models
The bar shows how this model’s price compares with every other model of the same kind on Synthorai. The cheapest and the most expensive are named at each end. These are base rates; batch, region and cache-write discounts are on the pricing page.
Specs & limits
Tokens
| Context window (vendor spec) | 1,050,000 |
|---|---|
| Max output (vendor spec) | 128,000 |
| Knowledge cutoff | 2026-02 |
Prompt caching
| How it caches | automatic |
|---|---|
| Min prefix | 1,024 |
| Lifetime | 5-10m, up to 1h |
Thinking
| Vendor control | reasoning.effort |
|---|---|
| Accepted values | none · low · medium · high · xhigh · max |
| Default | medium applied when the request sets nothing |
| Can be turned off | Yes |
| Thinking behaviour | The Responses API also takes reasoning.mode, either standard (the default) or pro; mode and effort are independent dials. |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image → text |
|---|
- Fastest, most affordable GPT-5.6 tier, designed for cost-sensitive high-volume workloads (successor to the nano tier)
- keeps the family's full 1.05M context / 128k max output
- cached input at 10% of list with 1.25x cache writes
- prompts over 272k input tokens billed at 2x input / 1.5x output
One prompt, measured through the gateway
GPT-5.6 Luna passed · 3 sentences
Enabling reasoning causes the model to use substantially more computational steps and generated tokens per request, even when the visible answer is similar. Because our provider charges based largely on token consumption and compute, that increased processing translated into roughly twice the cost. We can control the expense by reserving reasoning for complex tasks, setting token and effort limits, and monitoring cost per successful outcome.
out 146 tok (+60 thinking) latency 3.1 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
GPT-5.6 Luna passed · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 else: best = max(best, cur) cur = 1 return max(best, cur) ``` The bug is that `cur` counts equal *transitions* rather than the number of items in the current run, so a single-element run returns `0` and a run of length `n` returns `n - 1`; additionally, `best` is only updated when a run is interrupted, so a run continuing through the final element is not finalized before returning. Initializing the current run to one item, resetting it to one after a change, and taking a final `max` fixes both issues.
out 356 tok (+161 thinking) latency 4.7 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
GPT-5.6 Luna passed · 5/5 fields, guidance "Withheld pending the Q4 close"
{"company":"Meridian Robotics","quarter":"September quarter","revenue_usd_m":412,"growth_pct":null,"guidance":"Withheld pending the Q4 close"}
out 227 tok (+181 thinking) latency 3.6 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
GPT-5.6 Luna passed · 120 words, 0 banned, 1 question
Introducing PromptCache, an API gateway feature that caches prompts across providers, helping teams reduce latency, control spend, and deliver consistent results. How much faster could your applications respond when repeated prompts are served from a shared cache instead of being sent upstream? PromptCache supports provider-aware routing, configurable time-to-live policies, encrypted storage, cache invalidation, and usage analytics through one operational layer. It works with language-model providers while preserving your authentication, observability, and fallback workflows. Developers can enable caching by endpoint, model, tenant, or prompt pattern, then monitor hit rates and savings in real time. Built for production workloads, PromptCache gives platform teams controls for performance and cost without requiring application rewrites. […]
out 948 tok (+778 thinking) latency 8.0 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use GPT-5.6 Luna in 30 seconds
OpenAI-compatible: swap the base_url, keep your SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="gpt-5.6-luna",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "gpt-5.6-luna",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "gpt-5.6-luna",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "gpt-5.6-luna",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("gpt-5.6-luna")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About GPT-5.6 Luna
- OpenAI's model-selection guidance points to Luna for efficient, high-volume work, to Terra for strong performance at a lower price, and to Sol when flagship capability is the requirement.
- It keeps the family's full 1,050,000-token context window (vendor spec) and 128K max output tokens, takes image input, supports reasoning tokens, and reaches the hosted tool set including web search, file search, code interpreter, computer use, hosted shell, apply patch, skills, tool search, and MCP, with a February 2026 knowledge cutoff.
- Reasoning effort omitted from a request resolves to medium across this generation, and the ladder reaches the new max level for the hardest cases.
- Cached input is billed at a tenth of the list input price with cache writes at 1.25x, which suits pipelines that reuse long prompts, while prompts above 272K input tokens are billed at 2x input and 1.5x output for the whole request.
- Function calling, streaming, structured outputs, and Batch are all supported.
- Synthorai serves GPT-5.6 Luna through the same OpenAI-compatible chat completions endpoint as every GPT model.
FAQ
Is the GPT-5.6 Luna API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $1/M input tokens, that credit alone covers roughly 125 requests of ~8K tokens against GPT-5.6 Luna.
What is GPT-5.6 Luna best at?
Fastest, most affordable GPT-5.6 tier; keeps the family's full 1,050,000-token context; cached input at a tenth of the list price. See the About section for the full picture from the vendor's own release notes.
How much does GPT-5.6 Luna cost?
GPT-5.6 Luna costs $1 per million input tokens and $6 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.1/M.
Does GPT-5.6 Luna support prompt caching?
Yes, automatically: OpenAI-served prompts cache with no code changes. Cached input tokens bill at $0.1/M vs $1/M uncached; prompts need a 1,024-token stable prefix to cache (TTL 5-10m, up to 1h). Prompt caching guide →
How do I get access to GPT-5.6 Luna?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="gpt-5.6-luna", and you're done. One API key covers every model on the gateway.
What is GPT-5.6 Luna's knowledge cutoff?
GPT-5.6 Luna's knowledge cutoff is 2026-02, per the vendor's official documentation (as of 2026-07-10).
Related models
Compare
Every value on this page is transcribed from the vendor's own documentation, linked above, and carries the date it was checked. Prices are compared across the catalogue; specification values that vendors define differently are shown with the difference stated rather than charted. Nothing here is measured by us, and nothing is scored.