Home → Guides → GPT-6 Astra in production

GPT-6 Astra in production

Every number on this page comes from calls that actually ran and were actually billed on this platform. Nothing here is an estimate.

The short version

List price is $10.00 per 1M input and $50.00 per 1M output, with cache reads at $1.00 per 1M. We did not take that from a press release — we reconciled it against real invoices, and the arithmetic is shown below.
Cache reads decide the bill. Across our own traffic, 71% of all input tokens arrived as cache reads. Billed at a tenth of the input rate, they saved more money than the entire remaining invoice.
There is a cliff at 272,000 input tokens. Cross it and the whole request reprices at a higher rate — not just the tokens past the line.
It is not a high-frequency model. Median first token in our measurements was 878.0 ms and a long generation ran to 162 seconds. For classification or routing, a smaller model is both cheaper and faster.

List price, verified against an invoice

Most pages quote a vendor's list price. Here is ours checked against a real billed call — the first gpt-6-astra request that ever ran on this platform:

input       19,972 tokens  ×  $10.00 / 1M  =  $0.19972
output          36 tokens  ×  $50.00 / 1M  =  $0.00180
cache read   3,840 tokens  ×  $ 1.00 / 1M  =  $0.00384
                                              ─────────
                                              $0.20536

invoice line for that call:                   $0.205360

Exact to the last digit, and it holds across all 14 calls we have measured. That is the whole reason to trust the rest of this page: the prices below are not copied, they are reconciled.

What it actually cost us

Every call to this model on this platform, with the numbers the billing system recorded. No selected highlights, no rounded-off example session.

Input	Output	Cache read	List price	First token	Total
19,972	36	3,840	$0.205360	2,068 ms	3.3 s
564	17	23,296	$0.029786	2,191 ms	3.0 s
592	36	23,296	$0.031016	1,713 ms	2.8 s
20,759	118	3,840	$0.217330	5,447 ms	9.4 s
1,246	129	24,320	$0.043230	4,637 ms	8.6 s
387	1,643	25,344	$0.111364	8,377 ms	57.8 s
23,072	113	0	$0.236370	717 ms	131.7 s
991	67	22,272	$0.035532	668 ms	8.8 s
19,428	193	0	$0.203930	684 ms	96.7 s
2,081	159	19,200	$0.047960	766 ms	9.3 s
2,311	2,477	19,200	$0.166160	775 ms	106.8 s
4,250	67	20,224	$0.066074	795 ms	5.2 s
583	107	25,344	$0.036524	660 ms	22.6 s
676	52	25,344	$0.034704	961 ms	161.6 s

14 calls · 96,912 input tokens · 5,214 output · 235,520 cache-read · $1.47 at list price. Regenerated automatically — if the numbers change, this table changes.

Caching saved more than the bill

Of 332,432 input tokens in total, 235,520 arrived as cache reads — 71% of everything sent. Cache reads bill at $1.00 per 1M against $10.00 for fresh input, so:

235,520 cache-read tokens
  at the input rate  $10.00 / 1M   =   $2.36
  at the cache rate  $ 1.00 / 1M   =   $0.24
                                       ──────────
  saved                                $2.12

total list-price cost of all 14 calls:  $1.47

The saving is larger than the entire invoice. That is not a quirk of our workload — it is what happens to any agent loop that resends the same context, which is precisely what this model is built for. If you are estimating a budget from the headline per-token price, you will overestimate by several times.

The corollary matters more: anything that invalidates the cache costs you the full input rate again. A timestamp near the top of a prompt, a request ID, a reordered tool list — each of those turns a $1.00 read into a $10.00 write-and-read.

The 272,000-token cliff

Requests above 272,000 input tokens are repriced at a higher rate for the entire call, not only for the tokens past the threshold. A request at 271,000 tokens and one at 273,000 tokens are not 1% apart on the invoice.

This is the single most surprising line item people hit with this model. If your pipeline occasionally stuffs a large corpus into one request, you will see bills that look inexplicable until you find the crossing. Cap the context assembly, or split the work into two calls that each stay under the line.

Measured latency

From the same 14 calls. First-token time is what a user feels; total duration is what an agent loop waits on.

	First token	Total duration
Fastest	660 ms	2.8 s
Median	878.0 ms	9.4 s
Slowest	8,377 ms	162 s

The spread is wide because output length drives it. Short answers came back in a few seconds; the longest generation in this sample ran 162 seconds. Plan timeouts accordingly — a 30-second client timeout will cut off legitimate long generations.

When not to use it

This is the most expensive model in the GPT line, and there are common cases where it is the wrong pick:

Classification, extraction, routing, tagging. High-volume, low-judgement steps. These dominate token counts in most pipelines and a small model handles them indistinguishably. Sending them here is the most expensive mistake available.
Anything a user waits on synchronously. Median first token was 878.0 ms in our measurements. For an interactive UI, that is felt.
Workloads with no context reuse. The economics above rest on cache reads. A pipeline that sends a fresh prompt every time pays the full input rate and loses the model's main cost advantage.
Anything that needs non-default sampling. See the parameter notes below.

The split that holds up in practice is between deciding and doing. Route the high-volume routine steps to a cheap model, keep this one for the final reasoning step, and the blended cost lands much closer to the cheap model than the expensive one.

Calling it

The API is OpenAI-compatible. Point the base URL here and pass the model name — nothing else in your code changes.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_KEY",
    base_url="https://apiclan.us/v1",
)

resp = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Hello"}],
)

The model string is gpt-6-astra, with hyphens. A misspelled model name returns a 404 from the edge, which means the request never reaches the gateway and never appears in your usage log — it looks exactly like a bad key. If a call fails and nothing shows up in your usage history at all, check the spelling and the base URL before you check anything else.

Using Claude Code or the Anthropic SDK for something else? Those clients append /v1/messages themselves, so their base URL is https://apiclan.us with no /v1. Full setup per client is in the base URL guide.

What you pay here

Per 1M tokens	List price	APICLAN	You save
Input	$10.00	$2.00	80%
Output	$50.00	$10.00	80%

Cache reads bill at the same fraction of their own rate. Full arithmetic, a calculator and the sibling models are on the gpt-6-astra price page.

Questions people actually ask

Is it worth it over gpt-5.6-sol?

For long agent runs and multi-step reasoning, often yes — the cache-read economics work in its favour once context reuse is heavy. For anything short or high-frequency, no: sol is half the list price and luna is a twentieth.

Why is my bill so much lower than the token count suggests?

Cache reads. In our own traffic 71% of input arrived cached and billed at a tenth of the input rate. That is normal for agent workloads, not an error.

Why did one request suddenly cost far more?

Two likely causes. Either you crossed 272,000 input tokens and the whole call repriced, or something invalidated the cache and the same context billed as fresh input at ten times the rate.

Can I set temperature or top_p?

Treat non-default sampling as unsupported on the newest reasoning models — several of them reject it outright with a 400. If you need controllable sampling, use an older generation.

Start using it

No subscription, no monthly minimum, no sales call. Top up with USDT and spend what you use — 1 USDT gives you 2 credits of API balance.

Read the 30-second quickstart

Prices quoted on this page are regenerated automatically from live billing data. Third-party terms are quoted from that party's own published documentation.