GPT-6 Astra is OpenAI's GPT-6 flagship, the first model of the generation exposed on the API.
- Input
- text image $10/M
- Output
- text $50/M
- Cache read
- $1/M
- Context
- 1.1M
- Knowledge cutoff
- 2026-04
Prompts over 272K tokens: the whole request bills at $20/M input · $75/M output
Benchmarks
Vendor-published: Alibaba (Qwen) Anthropic OpenAI
Price in context
Where the price sits among 65 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-04 |
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 GPT-6 flagship. Upstream exposes only the suffixed gpt-6-astra id
- there is no bare gpt-6 alias. 1.05M context / 128k max output (the output ceiling is the value upstream itself reports when asked for more). Prompts over 272k input tokens move the whole request onto the long-context rate. Two upstream restrictions carry over from the GPT-5.6 family: temperature accepts only its default, and function tools cannot be combined with reasoning on Chat Completions
One prompt, measured through the gateway
GPT-6 Astra passed · 3 sentences
Enabling reasoning makes the model do more work per request, often generating internal reasoning tokens that are billed even though they do not appear in the final answer. If traffic, model choice, and pricing stayed the same, those extra tokens likely explain why our bill doubled—not longer answers or more users. We should verify the usage breakdown, then reserve higher reasoning levels for tasks where improved results justify the added cost.
out 283 tok (+196 thinking) latency 17.2 s
Instruction following (exactly three sentences - countable), audience shaping (CFO register), and the hidden-thinking billing gap the token meters below expose.
GPT-6 Astra 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 counts equal adjacent pairs rather than items, so every nonempty run is undercounted by one: a single-element input returns `0`, and a run of three equal items returns `2`. Starting and resetting `cur` to `1` counts the first item of each run, while the empty-input check preserves a result of `0`. Updating `best` after each iteration includes runs ending at the last index without needing a final flush; the original also updated during trailing runs, but undercounted them.
out 321 tok (+131 thinking) latency 13.5 s
Whether the fix is actually correct (runnable), explanation density, and token efficiency on a bounded task.
GPT-6 Astra passed · 5/5 fields, guidance "Formal guidance is withheld pending the "
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": null, "growth_pct": "eleven and change", "guidance": "Formal guidance is withheld pending the Q4 close." }
out 329 tok (+267 thinking) latency 16.9 s
Schema obedience (no invented fields), hallucination pressure (guidance is explicitly withheld), and structured-output path differences.
GPT-6 Astra passed · 120 words, 0 banned, 1 question
Introducing Cross Provider Prompt Cache, a new API gateway feature that reuses eligible prompt content across supported AI providers. Why pay to process the same context every time? Configure caching once at the gateway, then route requests between models while keeping shared instructions, reference material, and conversation prefixes ready for reuse. Caching controls let teams set expiration windows, isolate tenants, and exclude sensitive content. Cache analytics show hit rates, estimated savings, and latency trends, helping developers tune performance with confidence. Existing routing policies continue to work, so adoption fits your current architecture. Start with a single application, measure the results, and expand as needed. Available today in the dashboard and API, with documentation and examples to guide your first deployment.
out 665 tok (+516 thinking) latency 19.3 s
Constraint obedience (word budget, banned-word list, the single question), style fingerprint, and length control.
Use GPT-6 Astra 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-astra",
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-astra",
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-astra",
"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-astra",
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-astra")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));About GPT-6 Astra
- Upstream publishes only the suffixed gpt-6-astra identifier, so there is no bare gpt-6 alias to fall back on.
- It pairs a 1,050,000-token context window with 128K max output tokens, a ceiling the API itself confirms by rejecting larger requests with an explicit limit, and accepts text and image input with structured outputs, streaming, tool use, prompt caching, and batch.
- Pricing is split by context length: prompts at or below 272K input tokens bill at the short-context rate, and anything above moves the whole request onto the long-context rate at roughly double the input and 1.5x the output.
- Two upstream restrictions carry over from the GPT-5.6 family and are worth planning around: temperature accepts only its default value, and function tools cannot be combined with reasoning on Chat Completions; use the Responses API or disable reasoning when you need tools.
- Synthorai serves GPT-6 Astra through the same OpenAI-compatible API as the rest of the fleet.
FAQ
Is the GPT-6 Astra API free to try?
Yes: new accounts get 10 trial calls and up to $1 in free credit, no card required. At $10/M input tokens, that credit alone covers roughly 12 requests of ~8K tokens against GPT-6 Astra.
What is GPT-6 Astra best at?
OpenAI's GPT-6 flagship, exposed only as gpt-6-astra; 1.05M context with a 128K output ceiling the API confirms itself; short- and long-context pricing split at 272K input tokens. See the About section for the full picture from the vendor's own release notes.
How much does GPT-6 Astra cost?
GPT-6 Astra costs $10 per million input tokens and $50 per million output tokens on Synthorai. That is the provider's list price, with no platform markup. Cached input tokens bill at $1/M.
Does GPT-6 Astra support prompt caching?
Yes, automatically: OpenAI-served prompts cache with no code changes. Cached input tokens bill at $1/M vs $10/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 Astra?
Point your existing OpenAI SDK at base_url="https://synthorai.io/v1", set model="gpt-6-astra", and you're done. One API key covers every model on the gateway.
What is GPT-6 Astra's knowledge cutoff?
GPT-6 Astra's knowledge cutoff is 2026-04, per the vendor's official documentation (as of 2026-09-07).
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.