GPT-6 Luna is the lightweight tier of OpenAI's GPT-6 family, released on September 22, 2026 alongside GPT-6 Sol.
- Input
- text image $0.1/M
- Output
- text $0.5/M
- Cache read
- $0.01/M
- Context
- 1.1M
- vs GPT-4o
- ~98% cheaper
- Knowledge cutoff
- 2026-05
Prompts over 272K tokens: the whole request bills at $0.2/M input · $0.75/M output
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic DeepSeek Google OpenAI Z.ai
Price in context
Where the price sits among 67 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-05 |
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 |
| Parameter | reasoning_effort |
| Values | minimal · low · medium · high the gateway's parameter surface - the vendor mapping above applies |
Model
| Modalities | text + image → text |
|---|
OpenAI's most efficient GPT-6 model for focused, high-volume tasks and the lowest-cost option in the family. 1.05M context of which up to 922K can be input, 128K max output. Prompts over 272K input tokens move the whole request onto the long-context rate (2x input and cache, 1.5x output). On Chat Completions, function calling works only with reasoning_effort set to none.
One prompt, measured through the gateway
GPT-6 Luna passed · 3 sentences
Enabling reasoning typically makes the model process more information and generate more internal tokens before producing its answer. Because usage is billed by tokens—and reasoning may also route requests to a more expensive model—the cost per request can rise sharply. If request volume stayed similar, that higher cost per request could explain why the bill doubled.
out 117 tok (+48 thinking) latency 3.4 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
GPT-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: cur = 1 best = max(best, cur) return best ``` The original code counted matching *adjacent pairs* rather than items, so a run of length `n` was reported as `n - 1`, and a single-item input returned `0`. This version counts the current item as part of each run and updates `best` at every index, including the last; it returns `0` for an empty input.
out 514 tok (+356 thinking) latency 6.9 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
GPT-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 161 tok (+119 thinking) latency 21.7 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
GPT-6 Luna passed · 120 words, 0 banned, 1 question
Introducing Prompt Cache, a new API gateway feature that recognizes repeat prompt prefixes and reuses provider-side cached context across supported models. Teams can route requests to different AI providers while preserving eligible cache hits, reducing redundant input processing and helping lower latency and token costs. Configure cache policies in one place, monitor hit rates by provider, and keep existing client integrations unchanged. The gateway applies provider-specific rules automatically, so developers do not need to build separate caching logic for each endpoint. Which workflows could benefit from faster responses and predictable spend? Prompt Cache is available today in preview for eligible accounts, with usage details, supported providers, and setup guidance in the dashboard. Start with one route, compare results, then expand.
out 959 tok (+813 thinking) latency 14.6 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use GPT-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-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-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-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-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-6-luna")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About GPT-6 Luna
- OpenAI calls it its most efficient model for focused, high-volume tasks and the lowest-cost option in the GPT-6 family, which makes it the natural fit for summarization, extraction, classification, and routing at scale.
- It does not trade away the family's limits to get there: it keeps the 1,050,000-token context window, of which up to 922,000 tokens can be input, 128K max output tokens, text and image input, structured outputs, streaming, tool use, and prompt caching, with a May 2026 knowledge cutoff.
- Reasoning effort runs from none to max with medium as the default, so a high-volume deployment can dial it down per request instead of switching models.
- Prompts above 272K input tokens move the whole request onto the long-context rate at twice the input and 1.5x the output price.
- As with the rest of GPT-6, function calling on Chat Completions works only when reasoning_effort is none; use the Responses API when you need tools and reasoning together.
- Synthorai serves GPT-6 Luna through the same OpenAI-compatible API as the rest of the fleet.
FAQ
Is the GPT-6 Luna API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $0.1/M input tokens, that credit alone covers roughly 1,250 requests of ~8K tokens against GPT-6 Luna.
What is GPT-6 Luna best at?
Lowest-cost model in the GPT-6 family; built for focused, high-volume tasks; keeps the full 1.05M context and 128K output. See the About section for the full picture from the vendor's own release notes.
How much does GPT-6 Luna cost?
GPT-6 Luna costs $0.1 per million input tokens and $0.5 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $0.01/M.
Does GPT-6 Luna support prompt caching?
Yes, automatically: OpenAI-served prompts cache with no code changes. Cached input tokens bill at $0.01/M vs $0.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-6 Luna?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="gpt-6-luna", and you're done. One API key covers every model on the gateway.
What is GPT-6 Luna's knowledge cutoff?
GPT-6 Luna's knowledge cutoff is 2026-05, per the vendor's official documentation (as of 2026-09-23).
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.