GPT-6 Astra API: The Model ID, the Endpoint, and What a Long-Horizon Task Actually Costs

The short version: GPT-6 Astra is callable today at https://api.openai.com/v1 under a single model id, gpt-6-astra, at $10.00 per million input tokens, $1.00 cached input and $50.00 output — the figures Ope​nAI's own pricing page carried on September 16, 2026. The model itself is from September 3, 2026, thirteen days before this page was written, so nothing here is launch coverage and nothing here is framed as an announcement. This is the reference page for the developer question that comes after availability: what string to pass, which endpoint takes it, what the 1,050,000-token window really buys, what the account has to look like first, and what one genuine long-horizon agent run costs on a rate card that quietly reprices itself above 272,000 input tokens. GPT-5.6 Sol appears throughout only as the price baseline it is sold above, never as the subject.

The reason a thirteen-day-old model deserves a page this week is that the routes into it changed after the launch did, and the API route is now the ordinary one. When Ope​nAI shipped Astra on September 3 it described a rollout rather than an availability; by September 8 it was saying the model was fully rolled out to Plus, Pro, Business and Enterprise users in Co​dex and ChatGPT Work, and by the week of September 14 AWS was listing it on Bedrock and Microsoft Foundry was carrying it generally available. For an API caller that sequence matters less than it sounds — the endpoint has been live and documented the whole time — but it does mean the procurement questions around it now have answers they did not have on launch day. Everything below was read from Ope​nAI's own model documentation, pricing page and data-controls page on September 16, 2026, and anything that comes from somewhere else says so in the sentence that carries it.

The model id, and the snapshot question answered honestly

The string to pass is gpt-6-astra — lower case, hyphenated, no vendor prefix. That is the only id Ope​nAI documents for this model.

If you are looking for a dated snapshot to pin, there is not one to find, and we are not going to invent a plausible-looking suffix. Ope​nAI's model page for GPT-6 Astra lists exactly one entry under Snapshots, and it is the bare gpt-6-astra. There is no -2026-09-03-style dated form and no -latest alias on the vendor's side. We saw a moving alias of the ~openai/gpt-astra-latest shape on a router listing during research; that is a gateway construct built on top of the vendor id, not something Ope​nAI publishes, and it should not go into your config as though it were.

The practical consequence is small but worth stating. You can retrieve the model object to confirm what you are talking to:

curl https://api.openai.com/v1/models/gpt-6-astra -H "Authorization: Bearer $OPENAI_API_KEY"

Pin the bare id in a config value rather than typing it into a dozen call sites. If Ope​nAI later adds dated snapshots, the bare id becomes the moving target and your pinned value starts changing underneath you — one place to edit is the difference between a two-minute change and an afternoon of grepping.

The endpoint: base URL, compatibility, and a request that runs

The base URL is https://api.openai.com/v1. Per Ope​nAI's model documentation, GPT-6 Astra is supported on Responses (/v1/responses), Chat Completions (/v1/chat/completions) and Batch (/v1/batch). It is explicitly not supported on Realtime, Assistants, Fine-tuning, Embeddings, image generation and editing, video, audio, moderation, or the legacy Completions endpoint — and those absences matter as much as the presence list, because a team that planned around the Assistants API or a fine-tuned variant has to replan rather than rewrite.

On compatibility: this is Ope​nAI's own first-party API, which is the wire format every Ope​nAI-compatible SDK and client was written against. Anything that speaks that format will talk to gpt-6-astra without a shim — you change the model string and, if you are migrating from an older Ope​nAI model, the parameter names below. New work should use the Responses API: it is the surface on which Ope​nAI documents this model's reasoning control, it is where the built-in tools live, and Chat Completions support for the newest models has historically been the shallower of the two.

A minimal streaming call, with reasoning effort set:

curl https://api.openai.com/v1/responses \

-H "Authorization: Bearer $OPENAI_API_KEY" \

-H "Content-Type: application/json" \

-d '{"model": "gpt-6-astra", "input": "List the files you would change to move this service off the legacy auth API.", "reasoning": {"effort": "high"}, "max_output_tokens": 16000, "stream": true}'

And the same thing in Python, which is where most readers will actually live:

from openai import OpenAI

client = OpenAI()

stream = client.responses.create(model="gpt-6-astra", input="List the files you would change to move this service off the legacy auth API.", reasoning={"effort": "high"}, max_output_tokens=16000, stream=True)

for event in stream:

if event.type == "response.output_text.delta": print(event.delta, end="")

Three things about that request are specific to this model rather than copied from a generic quickstart.

• Reasoning effort is a cost dial, not only a quality dial. Ope​nAI's model page lists the supported values as low, medium, high, xhigh and max. Note where that list starts: there is no none or minimal for GPT-6 Astra, so the floor moved up. Reasoning tokens are billed as output tokens at $50.00 per million, which means turning effort from high to max is a decision with a price attached, not a free quality upgrade.

• Streaming is supported, and it is the honest way to run long turns. A single request on this model can emit up to 128,000 output tokens. Waiting for that to land in one response body, with no visibility into whether it is progressing, is how you end up guessing at timeouts.

• Prompt caching is explicit here. The Responses API documents a prompt_cache_breakpoint on text, image and file content, with a mode of explicit, marking "the exact end of a reusable prompt prefix" and inheriting its TTL from the request's prompt_cache_options.ttl. On a model whose cached input rate is a tenth of its uncached rate, where you place that boundary is the highest-leverage line in your request.

What a 1,050,000-token window actually means

The documented numbers are a 1,050,000-token context window, a 922,000-token maximum input, a 128,000-token maximum output, and a knowledge cutoff of April 30, 2026.

Start with the arithmetic that people miss: 922,000 plus 128,000 equals 1,050,000. The window is shared between what you send and what the model may return, and the output ceiling is reserved out of it. You cannot send 1,050,000 tokens of input; the practical ceiling for a single request is 922,000, and less than that if you want room for a real answer.

What does a million tokens buy in the units you actually work in? Token-to-text conversions are approximate, and these are ours rather than Ope​nAI's, but they are the right order: at roughly four characters per token, 1,050,000 tokens is on the order of 750,000 words, or something like a hundred thousand lines of code. That is a mid-sized repository, whole, with room left for the tool output an agent generates while it works. The long-horizon case the model is sold for is exactly this: an agent that read a file an hour ago and can still see what it said, instead of one that has compacted the morning into a paragraph of summary.

Then the part that belongs on a cost page rather than a spec page. Ope​nAI's model documentation states that prompts with more than 272,000 input tokens are priced at 2x input and cache rates and 1.5x output for the full request. The pricing page carries it as a second row: long context on GPT-6 Astra is $20.00 input, $2.00 cached input and $75.00 output. So the top three-quarters of that window is a price band, not just headroom. A run whose transcript sits above 272,000 tokens pays double on every input token — including the cached ones — for the whole request, and that is the single largest swing in this model's economics. It is worked through in full below.

One further mechanic worth knowing, because it is the vendor's own acknowledgement that one window is not the whole answer. For Co​dex, Ope​nAI describes an experimental context approach shipping with Astra in which notes persist across context windows instead of repeated compaction into a single summary, with earlier windows staying searchable so requirements and test results from earlier messages and tool output remain findable. Ope​nAI calls it experimental, says it is enabled in the Co​dex config.toml, and says it will become the default for Astra. If you are building the equivalent yourself on the API, that is the shape to copy: durable notes plus retrievable history, rather than one heroic prompt.

And the limit of the number itself: a large window is a capacity, not a guarantee of attention across it. The vendor-reported long-horizon figures are a better guide to behaviour than the token count — Ope​nAI reports OSWorld 2.0 at 72.6% at roughly 40 minutes per task, and Terminal-Bench 4.0 at 57.9% against 37.3% for GPT-5.6 Sol. Those are Ope​nAI's own numbers, unreproduced by us, and the independent picture is close but not identical: Artificial Analysis measured Astra at 59.1% on Terminal-Bench v4.0 against 52.0% for Claude Fable 5.1 and 39.9% for GPT-5.6 Sol. Both agree the long-horizon gap over the previous generation is real; neither is a substitute for running your own task.

Input modalities, and the file question left honestly open

Ope​nAI's model page lists input modalities of text and image, with text output. No audio, no video, no image generation on this model.

Image input goes in as a content part inside a user message. The part type is input_image, and the image is supplied either as a fully qualified URL or a base64 data URL on image_url, or as a file_id from the Files API. There is an optional detail of auto, low, high or original, defaulting to auto. The shape is:

{"model": "gpt-6-astra", "input": [{"role": "user", "content": [{"type": "input_text", "text": "what changed in this screenshot?"}, {"type": "input_image", "image_url": "data:image/png;base64,...", "detail": "high"}]}]}

Ope​nAI's vision documentation lists PNG, JPEG, WEBP and non-animated GIF as accepted, up to 512 MB of total payload per request and up to 1,500 images per request, with images over 30,000 patches rejected rather than resized down. Those are the platform's general vision limits rather than Astra-specific ones, and images bill as tokens like any other input.

Now the question readers actually arrive with, and the honest answer. Can you send files or PDFs? We could not confirm document input for this model on Ope​nAI's documentation, and we are not going to imply it works. The Responses API does define an input_file content part, so the plumbing exists in the API generally; but Ope​nAI's page for GPT-6 Astra lists text and image as its input modalities and does not list file, and we found no Ope​nAI statement documenting PDF input for this endpoint. A router listing for the same model does show file alongside text and image — treat that as router-reported, which is what a router records about a route rather than what the vendor guarantees. If document ingestion is load-bearing for your workload, test it against the real endpoint before you build on it, and have an OCR-to-text fallback ready. That is the difference between an afternoon of testing and a rewrite.

The full price line, and one long-horizon run priced out

Every figure in this section was read from Ope​nAI's own pricing page on September 16, 2026, and all are per million tokens at the Standard tier unless the line says otherwise.

• Short context, up to 272K input — $10.00 input, $1.00 cached input, $12.50 cache write, $50.00 output.

• Long context, above 272K input — $20.00 input, $2.00 cached input, $25.00 cache write, $75.00 output, applied to the full request.

• Batch and Flex — half of Standard: $5.00 / $0.50 / $6.25 / $25.00 short context, $10.00 / $1.00 / $12.50 / $37.50 long context.

• Fast mode — double Standard: $20.00 / $2.00 / $25.00 / $100.00 short context, $40.00 / $4.00 / $50.00 / $150.00 long context. Ope​nAI notes Fast mode is unavailable for GPT-6 Astra with EU data residency.

• Data residency — endpoints using it carry a 10% uplift for models released on or after March 5, 2026. GPT-6 Astra qualifies, so a residency deployment sits 10% above every number above.

The line to internalise is the cached input rate. $1.00 against $10.00 is a 90% discount on the part of the prompt you send again — and on an agent workload, that is almost the whole prompt. Cache writes are billed at $12.50, or 1.25x the uncached input rate, so the break-even is simple: 100,000 tokens sent uncached twice costs $2.00, while writing that prefix once and reading it back once costs $1.35. Caching pays from the second reuse onward, and an agent working the same transcript for a hundred turns reuses it a hundred times.

Which brings us to the arithmetic that actually decides whether this model is affordable, because the headline rate is not the number that lands on the invoice. Here is a modelled run — ours, built on Ope​nAI's published rates, not a measured bill — for the kind of task the model is sold for: an autonomous coding agent working a repo-scale migration over a few hours, 120 model calls, a working transcript that averages around 500,000 input tokens per call as it accumulates, 80% of that input served from cache, and 400,000 output tokens across the run including reasoning.

At short-context Standard rates:

• Uncached input — 12M tokens × $10.00 = $120.00

• Cached input — 48M tokens × $1.00 = $48.00

• Output — 0.4M tokens × $50.00 = $20.00

• Total ≈ $188.00 for the run

The same run at the long-context band, which is what a transcript that sits above 272,000 tokens per call actually gets:

• Uncached input — 12M tokens × $20.00 = $240.00

• Cached input — 48M tokens × $2.00 = $96.00

• Output — 0.4M tokens × $75.00 = $30.00

• Total ≈ $366.00 for the run

Two conclusions fall out of that, and neither is visible from the headline rate. First, where your transcript lives is worth as much as which model you pick — the identical task roughly doubles depending on whether it crosses the 272K threshold, which makes context discipline (retrieving the right 100K rather than carrying 600K) a cost-control technique on this model, not just a performance one. Second, caching is worth more than the discount suggests: with no cache hits at all, the first scenario carries $600.00 of input instead of $168.00, and the run costs about $620 rather than $188. Turn caching on before you turn reasoning effort up.

For the baseline, the same token mix on GPT-5.6 Sol at the rates Ope​nAI's pricing page showed on September 16 — $4.00 input, $0.40 cached input, $20.00 output at short context — comes to roughly $75.20, and at Sol's long-context row ($8.00 / $0.80 / $30.00) roughly $146.40. That makes this run about 2.5x on either band. Two caveats on that multiple, because it has already caused confusion elsewhere: Sol's number is a promotional rate — Ope​nAI says the promotion is available at least through November 21, 2026 — while Astra's is list, so the multiple measures today's two rate cards rather than a stable fact about the models, and it narrows if the promotion lapses. And the older "2.5x" that circulates for Astra is sometimes computed against Sol's pre-promotion list of $5.00/$30.00, which gives 2x on input and about 1.67x on output. Name which Sol rate you mean or the number is worthless.

One more line: the Batch tier halves all of it, taking the first run to roughly $94. Whether you can use it depends on the next section.

Zero Data Retention, and the discount that disqualifies itself

Ope​nAI states that Zero Data Retention is available for eligible API customers on supported endpoints, subject to approval — and both halves of that sentence do real work. It is not a self-serve toggle: eligibility is subject to prior approval by Ope​nAI and acceptance of additional requirements, and you start it by talking to sales. Once approved, it is configured at organisation or project level under Settings → Organization → Data controls, on the Data Retention tab, where a project can inherit the organisation default, set ZDR explicitly, select Modified Abuse Monitoring, or disable both.

What it changes in practice: ZDR excludes customer content from abuse monitoring logs, replacing the default retention of up to 30 days, and the store parameter on /v1/responses and /v1/chat/completions is treated as false even if a request tries to set it true.

The detail that matters most on a page about cost: /v1/batches is not on the ZDR-eligible endpoint list. Ope​nAI's data-controls page lists it as ineligible, with application state retained until deleted. So on GPT-6 Astra the Batch tier's 50% discount and Zero Data Retention are mutually exclusive — a compliance-bound workload that needs ZDR should budget the Standard rate, not the batch rate, and the $94 figure above is not available to it.

Three further caveats, stated plainly because a page that oversells ZDR is worse than one that omits it. ZDR is not absolute: under "Eyes Off" Ope​nAI reserves the right to make models ineligible for ZDR for specific customers, with advance written notice, and under "Safety Retention" content may be retained and human-reviewed where classifiers flag severe risk. Image and file inputs flagged for potential CSAM are retained for manual review even under ZDR. And ZDR stops at Ope​nAI's boundary — if your agent calls a remote MCP server or another vendor's API, that traffic is governed by that party's retention policy, not this one. Separately, data residency is a different control from ZDR, requires its own approval and a Modified Retention amendment outside the United States, and carries the 10% uplift noted above. If you are relying on caching under ZDR, read Ope​nAI's data-controls page for what caching retains; we are not going to print a retention figure for it that we could not read there ourselves.

Rate limits as documented, and the one that bites first

Ope​nAI's model page publishes these per-tier limits for GPT-6 Astra — requests and tokens per minute, then the batch queue limit:

• Tier 1 — 500 RPM, 500,000 TPM, batch queue 1,500,000

• Tier 2 — 5,000 RPM, 1,000,000 TPM, batch queue 3,000,000

• Tier 3 — 5,000 RPM, 2,000,000 TPM, batch queue 100,000,000

• Tier 4 — 10,000 RPM, 4,000,000 TPM, batch queue 200,000,000

• Tier 5 — 15,000 RPM, 40,000,000 TPM, batch queue 15,000,000,000

Two limits we will name as not documented rather than fill in: there is no published free-tier limit, because GPT-6 Astra is not on the free tier at all; and we found no published ceiling above Tier 5 and no separate limit table for Fast mode. If a vendor has not published a limit, treat the absence as unresolved — do not assume it is unlimited.

The number that bites an agent workload first is Tier 1's 500,000 TPM. A single call on this model can carry a 500,000-token transcript, which means one request can consume an entire minute of your token budget on the entry tier. A million-token context window is not much use to an agent that squats the same transcript across 120 turns if the tier cannot push the tokens. Size the tier against the token volume from the worked example above, not against the request count — and note that tier advancement depends on spend and account history, so it is worth establishing before a deadline rather than during one.

Azure and AWS Bedrock, one line each

• Microsoft Azure — GPT-6 Astra is deployable in Microsoft Foundry under the same gpt-6-astra id, with Foundry coverage dating general availability to early September 2026 and reporting Global Standard and US Data Zone deployments, no EU Data Zone at launch, and rates at or near Ope​nAI's list with a long-context row. We read that from Foundry coverage rather than Microsoft's own catalogue page, which we could not reach today — verify the current deployment list, region set and rate on Microsoft's own documentation before planning a deployment on it.

• AWS Bedrock — listed as openai.gpt-6-astra, available through supported Bedrock APIs and confirmed in AWS's weekly roundup dated September 15, 2026, with Bedrock's own governance perimeter (VPC endpoint isolation, KMS encryption, Guardrails) and AWS's statement that inference data is not used for model training. Reported in-region and geographic cross-region inference on Bedrock is billed 10% above base rates; that figure is second-hand in our reading, so check AWS's own pricing page.

Neither route changes the model. Both change procurement, which for an enterprise reader is the whole point: a Foundry or Bedrock deployment can sit inside an existing cloud commitment, inherit its IAM, logging and network boundary, and land on an invoice finance has already approved — frequently the difference between a pilot and something that actually ships. The trade is that you take the cloud's model lifecycle and the cloud's rate, and both clouds are reported at or above Ope​nAI's list rather than below it.

Where a router fits, including the parts that argue against it

GPT-6 Astra is in the OrcaRouter catalogue as openai/gpt-6-astra, and OrcaRouter passes provider list price through at 0% markup — the vendor's price is our price, and a vendor price move lands in your bill the same day rather than at renewal. On a model at this price that is not a rounding-error claim: the arithmetic above is the same arithmetic you would pay direct.

The honest case for routing here is not the price, it is the reversibility. Astra is roughly 2.5x the model below it and its cost swings on a threshold your architecture controls, so most teams want to try it on a slice of real traffic before committing a production path. Through one key you can put it behind the same endpoint as the models you already run, send it part of the traffic, and fail over automatically to something cheaper when it is not earning the difference — a config change rather than a migration, with one API covering 200-plus models, a routing DSL that composes several models into a single call, and model fusion when you want a panel answering together.

The parts that argue against it, stated as plainly. A router is one more hop in the request path and one more party in the data flow — and on this model that is not hypothetical, because ZDR is approved per organisation at Ope​nAI and a routed request is not automatically covered by your ZDR approval. If you are sending regulated data, confirm the route's data terms before you send it, and be prepared to call the vendor directly for that workload. Routing also adds a component that can fail or add latency, and it makes swapping models so easy that it is possible to change what is answering your users without reviewing it. None of that outweighs the trial-and-reversibility case for most teams; all of it is worth knowing before you decide the router is free. We set the routing platforms against each other in a separate piece rather than restating the comparison here.

Three questions that are not one-clause answers

Can I fine-tune GPT-6 Astra, or use it with the Assistants API? No, on both counts, and this is a design boundary rather than a configuration you have missed. Ope​nAI's model page lists Chat Completions, Responses and Batch as the supported endpoints and explicitly lists Fine-tuning and Assistants as unsupported, and there is no GPT-6 Astra row in Ope​nAI's fine-tuning pricing table. If your architecture depends on a fine-tuned flagship, Astra has to be prompted instead, which moves the cost from training into input tokens — and at $10.00 per million on a large system prompt, that is a real budget line rather than a footnote.

Will the model refuse security work I am authorised to do? Sometimes, yes, and it is worth knowing before you build. GPT-6 Astra is the first Ope​nAI model to reach the Critical cybersecurity capability threshold under the company's Preparedness Framework, and as shipped it refuses advanced cyber tasks such as writing proof-of-concept exploits. Ope​nAI says it plans to widen access with less restrictive safeguards through its Daybreak programme. For a defender this shows up as a refusal that is not a rate limit and not a bug — budget for it in your error handling rather than retrying into it.

Do I need special approval to call this model? Not for the standard endpoint — there is no waitlist and no approval step to call gpt-6-astra, just an account with billing. What you may need approval for is everything around it: Zero Data Retention, which is application-gated; data residency outside the United States, which needs its own amendment; and a tier bump, if you intend to push agent-scale token volumes through a Tier 1 account. The model is the easy part of the procurement.

What to watch, and who should move now

If you are building on this model, the four things worth monitoring are all vendor-side and all dated. Whether Ope​nAI publishes a dated snapshot for gpt-6-astra — which would turn the bare id into a moving target and make pinning meaningful. Whether the 272,000-token threshold moves, because that single line is worth more to your bill than any benchmark on the page. Whether the Bedrock and Foundry rates converge on or stay above Ope​nAI's list, since that decides the procurement route as much as the model does. And whether the Daybreak programme changes what the endpoint will refuse, which for security teams is the difference between a usable tool and a demo.

As for who should act, the split is clean. If you are already paying for GPT-5.6 Sol at promotional rates for long-horizon agent work, the 2.5x is real and the question is narrow: does the task completion rate on your own workload beat the price difference? Run it on a slice of real traffic and find out — the worked example above tells you what the slice costs before you start. If your work is short-context chat or high-volume classification, this is not your model; the long-context reprice and the $50.00 output rate make it an expensive way to do something GPT-5.6 Luna does for a fraction of the price. And if you are an enterprise with a compliance requirement, start the ZDR conversation first, because it gates the Batch discount, the residency uplift and your choice of route — and none of that is a decision you can make on the day you need it.