Ask “what is the latest GPT version?” in September 2026 and you get a concrete answer with a short shelf life: as of September 8, 2026, the latest GPT model is GPT-6 Astra, and its OpenAI API model ID is gpt-6-astra. OpenAI began rolling it out on September 3, 2026, per CNBC’s coverage of the rollout, and it sits at the top of OpenAI’s API model list. This article is not that model’s price page — the full GPT-6 Astra rate card is our GPT-6 Astra API pricing guide, and we borrow one row of it here. What this one covers is the question the news pages skip: what happens when you write model as a moving target instead of a concrete ID — specifically the ~openai/gpt-latest alias — what it points at today, what the September switch did to a real bill, how to detect a switch, and when “always newest” is the wrong default. We run Modellix, an API gateway listing 29 language models behind one key, so we have a commercial interest in the alias mechanism below; every price figure was captured September 8, 2026, and anything derived is flagged as such.
What “the latest GPT model” means in API terms right now
Three different answers travel under “latest GPT model” in September 2026, and only one of them is about the API:
- The product answer — the newest GPT in ChatGPT. That is GPT-6 Astra, per OpenAI’s announcement. Useful if you shop subscriptions; irrelevant to the code you are writing.
- The snapshot answer — the newest concrete model ID OpenAI publishes:
gpt-6-astra, documented with its 1,050,000-token context window, 128,000 max output tokens, and $10 / $1 / $12.50 / $50 per-million rates on OpenAI’s GPT-6 Astra model page. Hardcodegpt-6-astraand that is what you get, until OpenAI retires the snapshot. - The moving-target answer — “I don’t want to track which ID is newest; I want the API to follow.” This is where the API-side meaning of “gpt latest” lives, and it is the one the search results skip.
The moving-target answer has a wrinkle worth knowing before you use it: OpenAI’s versioning model does not ship a cross-generation “latest” ID. OpenAI does use alias-style naming at family level — its catalog lists gpt-5.6 as an alias that resolves to gpt-5.6-sol — but for GPT-6 Astra the docs list exactly one snapshot under “Snapshots”: gpt-6-astra, with no -latest variant and nothing that would re-point your traffic when a GPT-7 ships. If “follow the newest GPT forever” is the behavior you want, OpenAI’s API is not where it exists.
OpenAI ships snapshots; the ~openai/gpt-latest alias is a gateway construct
This is the fact that makes the whole keyword interesting: the API-side answer to “gpt latest model” as a moving target is not on OpenAI’s side at all. It is a capability of aggregation layers like the Modellix LLM gateway, whose docs describe stable aliases in the ~provider/series-latest form:
“Call the newest LLM in a model family through one stable alias without updating your client for every version. … When a new version ships, the alias changes target and your client stays unchanged.”
The gateway maintains twelve of these aliases today (snapshot captured September 8, 2026, matching the live price page):
| Latest Model ID | Routes to (as of 2026-09-08) |
|---|---|
~openai/gpt-latest |
openai/gpt-6-astra |
~anthropic/claude-fable-latest |
anthropic/claude-fable-5.1 |
~anthropic/claude-opus-latest |
anthropic/claude-opus-5 |
~anthropic/claude-sonnet-latest |
anthropic/claude-sonnet-5 |
~anthropic/sonnet-latest |
anthropic/claude-sonnet-5 |
~anthropic/claude-haiku-latest |
anthropic/claude-haiku-4.5 |
~google/gemini-pro-latest |
google/gemini-3.1-pro |
~google/gemini-flash-latest |
google/gemini-3.8-flash |
~moonshot/kimi-latest |
moonshot/kimi-k3 |
~qwen/qwen-latest |
qwen/qwen3.8-max |
~xai/grok-latest |
xai/grok-4.6 |
~zai/glm-latest |
zai/glm-5.3 |
The table ships with its own disclaimer, verbatim: “Targets change as each family evolves. The mappings on this page are current.” The ~ prefix is required, and the alias is per-series, not per-company — note the two sonnet rows share a target, while a family with no alias (DeepSeek, for example) simply has no latest tag at all. Treat the table like a rate card: a point-in-time snapshot, not a promise about tomorrow.
Illustrative Modellix artwork, not a product screenshot: a series-latest alias re-points to the newest model in its family while the client code stays unchanged. No dates or prices shown.
What the September 2026 switch actually cost
Between two snapshots four days apart, ~openai/gpt-latest changed targets: on September 4, 2026 it resolved to openai/gpt-5.6-sol; on September 8, 2026 it resolves to openai/gpt-6-astra (the September 8 state was re-verified against the live page while writing this). Your request body did not change — same model: "~openai/gpt-latest", same client. What changed is the model your requests actually hit, and therefore the rate they are billed at. The Modellix price page states this rule in advance, verbatim: “Billed at the current target rate.“ Pricing follows the current target; the alias faithfully followed an upstream model that costs more. This is a cost characteristic intrinsic to the “follow the latest” choice — disclosed on the page before the switch — not a Modellix price increase, and nothing about the gateway’s own fees changed.
The size of the follow, on the gateway’s listed rates (all captured September 8, 2026, per 1M tokens, requests at or under 272K input tokens):
| Dimension | openai/gpt-5.6-sol (Sept 4 target) |
openai/gpt-6-astra (Sept 8 target) |
Ratio (derived) |
|---|---|---|---|
| Input / 1M tokens | $3.60 | $9.00 | 2.5× |
| Output / 1M tokens | $18.00 | $45.00 | 2.5× |
| Cached read / 1M tokens | $0.36 | $0.90 | 2.5× |
| Cached write / 1M tokens | $4.50 | $11.25 | 2.5× |
The “2.5×” column is derived, not official: it is the quotient of the two models’ Modellix-listed prices above, both captured September 8, 2026 — no OpenAI statement and no Modellix statement describes it that way. The same derived ratio holds on the above-272K input tier of both models ($7.20 → $18.00 input, $27.00 → $67.50 output, $0.72 → $1.80 cached read, $9.00 → $22.50 cached write); how that tier works is a pricing-mechanics question for the GPT-5.6 pricing guide and the GPT-6 Astra rate card, not this article. What matters is the shape of the event: four billing dimensions, both tiers, same 2.5× multiple, zero code changes. On a workload doing, say, 10M input and 2M output tokens a month at the under-272K rate, that is $72.00 → $180.00 on the same rows — you can reproduce any such delta on the price page’s cost calculator by entering identical token counts against the two model IDs.
And here is a coincidence worth stating without interpretation. The alias section of that same page closes with: “For evaluations or regression tests, use a fixed model ID such as openai/gpt-5.6-sol.” The model ID the page holds up as the pinning example is the exact model the alias had just stopped pointing at. That is what it is — a coincidence of timing between a documentation example and a model release; we are not reading it as a hint, a preview, or advice to revert, and you should not either.
How to tell the alias switched behind your back
Everything above is about the risk of a moving target. The operational question — “did mine move, and what did it cost me?” — has one direct answer: the request log. When you call ~openai/gpt-latest through the gateway, each request is recorded with the concrete model it resolved to, in a model object carrying provider and model_name. The LLM logs reference documents the read as GET /v1/logs on the gateway host (https://llm.modellix.ai/v1/logs):
1 | curl -sS "https://llm.modellix.ai/v1/logs?start_time=1754352000&end_time=1754438400" \ |
Two fields turn that log into a switch detector. First, model.model_name: every row shows whether the alias resolved to gpt-5.6-sol or gpt-6-astra on that request — you can see the day the target changed, per request, with no guessing. Second, cost, which the LLM API guide describes in the console’s billing unit (sub-pennies: divide by 10,000 for USD). Chart cost per day across the log window and the switch shows up as a step change on the day the target moved — the same request shapes suddenly billing 2.5×. That is the one piece of this story only a gateway can answer: when you call OpenAI directly with gpt-6-astra, there is no alias and no “which model did it resolve to” question to log.
Two honesty notes before you rely on that log. The documented query window spans at most 30 days (start_time and end_time, both required), and the documentation does not state how long logs are retained — “I can always look up a historical switch” is not something we can promise; pull what you need while the window covers it. And the price page says only that “the mappings on this page are current” — the docs do not state whether any change notification exists for alias re-targets. Treat the log as the detection mechanism, not a notification inbox.
Illustrative Modellix artwork: per-request log entries carry the concrete model an alias resolved to, next to its cost. Field layout is conceptual.
Read the GET /v1/logs reference
See the exact query parameters and response fields for LLM request logs in the Modellix documentation.
View DocsPin it or follow it: when “latest” is the wrong default
The September switch is one data point, and a single data point is not a pricing law. The only honest general statements are the mechanism and the measurement method: a series-latest alias is billed at whatever its current target costs, and the direction of the next move is unknowable in advance. Consider the counter-example sitting four rows up the same alias table: when ~google/gemini-flash-latest moved to Gemini 3.8 Flash in the same early-September batch, the actual rates did not change — same per-million input and output prices before and after. Aliases are not a discount program and not a surcharge program; they are a routing convenience with an unknown price delta attached to each re-target.
That framing points at the real decision, which is about predictability, not about which model is better:
- Keep following
~openai/gpt-latestwhen your code benefits from the newest model automatically — you never edit the client when a new GPT ships, and you accept that capability and price move together, with nothing for you to do. - Pin a concrete ID when a change would hurt more than it helps: evaluation and regression runs that must stay comparable across time, cost-sensitive pipelines, or anything with a budget you need to forecast. The gateway’s own docs point the same way — pinned IDs are for “evaluations or regression tests” — and OpenAI model versioning works fine with pinning:
gpt-5.6-solremains a callable snapshot with its own rate card. - Measure, don’t assume: on a weekly or monthly interval, pull
GET /v1/logsand comparemodel.model_nameandcostper day. If you cannot tell whether your target moved, you have not set up detection — and you may not learn that it moved until the bill does. This time it was more expensive; another time it may be cheaper or flat. The alias table above is the “what does it point at” check; the log is the “did it move” check. If you need more than one field’s worth of visibility, our agent observability guide covers full-stack options; here, one log field answers the question.
If the new target is too expensive: the fallback is one string
The cost of reversing course is deliberately small, which is the other half of why following an alias is a reasonable experiment. The gateway puts 29 language models — OpenAI, Anthropic, Google, DeepSeek, Qwen, xAI, and more — behind the same key and protocol surface, so “this target is too expensive” is resolved by editing the model field, not by opening new accounts:
- Revert to the previous, cheaper target explicitly:
model: "~openai/gpt-latest"→model: "openai/gpt-5.6-sol". You lose auto-upgrades and gain a stable rate — Sol’s rate card is in our GPT-5.6 pricing guide. - Or jump families —
model: "anthropic/claude-sonnet-5"or any other row is the same one-string change on the same key. - Before switching anything, run both model IDs through the price page’s cost calculator with your real token mix; the monthly delta is arithmetic you can see in one screen rather than discover on an invoice.
One catalog note for that comparison: our cross-vendor LLM API pricing comparison is a useful place to eyeball the whole field, but it was published as a 2026-09-03 snapshot of the catalog — its title still reads “28 Text Models,” and the table has since grown to 29 with GPT-6 Astra. Use it for shape; use the live price page (or this article’s September 8 figures) for current numbers.
Where that leaves you. “gpt latest model” is two engineering choices wearing one phrase. If you want to know which GPT is newest, the answer is dated and concrete: GPT-6 Astra, gpt-6-astra, as of September 8, 2026. If you want your API calls to chase “newest” automatically, you are choosing to ride an alias whose target — and therefore whose bill — can move without a code change, and with no guarantee that you will be told when it does; ride it with the detection in place: check what the alias resolves to today, log what it resolves to per request, and keep the pinned fallback one string away.
Track ~openai/gpt-latest on Modellix
Log in to see the live alias mapping, run both model IDs through the cost calculator, and pull per-request logs on one key.
LoginFrequently Asked Questions
What is the latest GPT version?
As of September 8, 2026, the latest GPT model is GPT-6 Astra, API model ID gpt-6-astra, which OpenAI began rolling out on September 3, 2026. If you call GPT models through the Modellix gateway with the ~openai/gpt-latest alias, it currently resolves to openai/gpt-6-astra.
Is ~openai/gpt-latest the same thing as OpenAI’s gpt-6-astra?
Not the same thing, though today they lead to the same model. gpt-6-astra is a concrete snapshot ID on OpenAI’s side — one model, fixed rate. ~openai/gpt-latest is a gateway alias that currently routes to openai/gpt-6-astra but re-points automatically when a newer GPT ships. OpenAI’s docs for GPT-6 Astra list only the single gpt-6-astra snapshot; the moving alias is not something OpenAI offers for it.
Will I be notified when the alias changes target?
The Modellix docs do not state whether change notifications exist for alias re-targets; the price page says only that “the mappings on this page are current.” The reliable detection mechanism is the request log — GET /v1/logs returns the concrete model.model_name each request resolved to. The docs do not state how long logs are retained either, so pull what you need while your 30-day query window covers it.
Is following the latest GPT model more expensive?
There is no general rule — a series-latest alias is billed at whatever its current target costs, and the next move can be up, down, or flat. The September 2026 ~openai/gpt-latest switch to GPT-6 Astra roughly multiplied the per-million rates by 2.5 (a derived figure from the two models’ listed prices on September 8, 2026), while the same period’s ~google/gemini-flash-latest move to Gemini 3.8 Flash left the actual rates unchanged. If you need cost predictability, pin a concrete ID for the workloads that must not surprise you.
Should I pin a model ID or keep using the alias?
Pin when the workload needs stable, comparable behavior — evaluations, regression tests, or anything with a budget you must forecast; the gateway’s own docs recommend a fixed model ID for exactly those cases. Keep the alias when automatic access to the newest model is worth an unknown future price delta. Either way, the fallback between them is one model string.
Figures above were captured September 8, 2026 from the Modellix LLM price page, from OpenAI’s GPT-6 Astra model documentation, from OpenAI’s model catalog, and from OpenAI’s GPT-6 Astra announcement. The 2.5× ratio is a derived value (the quotient of the two models’ listed rates), not an official statement from OpenAI or Modellix; alias targets change as each family evolves, and the mappings shown were current as of September 8, 2026. Modellix is an API aggregator with a commercial interest in this guide and is not affiliated with OpenAI. Access language models from OpenAI, Anthropic, Google, DeepSeek, Qwen, and more through a single API key at modellix.ai.
