GPT-4 Turbo explained: specs, GPT-4o comparison and the October 2026 shutdown

What OpenAI announced at DevDay 2023

GPT-4 had been out since March 2023 when OpenAI launched GPT-4 Turbo as a preview at DevDay. The announcement listed the changes that mattered to developers:

• A 128K context window, up from the 8K and 32K versions of GPT-4. OpenAI put 128,000 tokens at more than 300 pages of text in one prompt.
• Newer knowledge. The model knew about world events up to April 2023.
• Lower prices. $0.01 per 1,000 input tokens and $0.03 per 1,000 output tokens: three times cheaper for input and twice as cheap for output as GPT-4 8K.
• JSON mode and better function calling. A new response_format parameter constrained the output to valid JSON, and the model could call several functions in one message instead of one per round trip.
• Reproducible outputs. A beta seed parameter made the model return the same completion for the same request most of the time, useful for debugging and tests. Log probabilities for output tokens were promised within weeks.

Developers called the text model as gpt-4-1106-preview, and OpenAI promised a stable version for production within weeks. Image input came as a separate preview, gpt-4-vision-preview, with vision planned for the stable release. OpenAI also doubled the tokens-per-minute rate limits for all paying GPT-4 customers.

The same day brought the Assistants API, DALL·E 3 and text-to-speech (tts-1) to the API, and OpenAI said the Assistants API was built on the same capabilities as its new GPTs product. Those were separate products: text-to-speech is its own model, and GPT-4 Turbo itself reads text and images and writes text. API prices are now quoted per million tokens, so GPT-4 Turbo's launch price reads $10 input and $30 output.

How GPT-4 Turbo's model names map to snapshots

OpenAI ships a model as dated snapshots, fixed versions whose behaviour does not change, plus aliases that point at one of them. Its model pages present snapshots as the way to hold a model version still, so its performance and behaviour stay the same. GPT-4 Turbo went through three previews and a stable release in five months:

The release dates come from OpenAI's API changelog, which records GPT-4 Turbo with Vision reaching general availability on April 9, 2024. The stable snapshot accepts text and images, writes text, has a 128,000-token context window and a knowledge cutoff of December 1, 2023, later than the preview's April 2023.

The context window is shared between what you send and what the model writes. GPT-4 Turbo could take in a long contract or a large slice of a codebase in one request, but each response stopped at 4,096 output tokens. Tasks that produce long output, such as rewriting a whole document, had to be split across several calls.

The alias is the trap. When a new snapshot ships, OpenAI can move the alias to it, and every request that uses the alias gets a different model without a code change. The changelog records such moves: on January 13, 2026, for example, the gpt-4o-mini-tts and gpt-4o-mini-transcribe aliases were pointed at new December 2025 snapshots, and the previous versions stayed reachable only by their dated names. A pinned snapshot gives up automatic improvements in exchange for predictability, which is what a production system needs.

GPT-4 Turbo vs GPT-4o

GPT-4o arrived on May 13, 2024, five weeks after GPT-4 Turbo's stable release. OpenAI said that in the API it was twice as fast as GPT-4 Turbo, half the price and had five times the rate limits. OpenAI's own GPT-4 Turbo page now recommends a newer model such as GPT-4o. Side by side, from OpenAI's model pages as of September 2026:

Three differences matter in practice:

• Price. The first GPT-4o snapshot, gpt-4o-2024-05-13, still lists at $5 input and $15 output, half of GPT-4 Turbo. The current gpt-4o default costs a quarter of GPT-4 Turbo's input price.
• Structured Outputs. JSON mode only guarantees valid JSON. Structured Outputs, launched on August 6, 2024 and available from GPT-4o on, also guarantees that the JSON matches the schema you supply, and OpenAI recommends it over JSON mode whenever a model supports it. For an integration that parses model output into a database or an API call, that is the upgrade that removes a whole class of errors.
• Knowledge. Newer does not mean more recent. GPT-4o's knowledge cutoff is two months earlier than the stable GPT-4 Turbo's.

The comparison with GPT-4 itself is simpler. OpenAI's GPT-4 page lists gpt-4-0613 with an 8,192-token context window at $30 input and $60 output per million tokens; GPT-4 Turbo has about 16 times the context at a third of the input price.

What OpenAI released after GPT-4 Turbo

GPT-4o replaced GPT-4 Turbo six months after DevDay, and new models have followed every few months since, according to the changelog and OpenAI's announcements:

OpenAI introduced o1 on September 12, 2024 as a new series of models that reason at length before they answer. GPT-4.1 then stretched the context window: up to 1 million tokens, a June 2024 knowledge cutoff and, OpenAI said, 26% lower cost than GPT-4o for median queries. With GPT-5 the GPT and reasoning lines merged: it is a reasoning model with an adjustable effort setting and a 400,000-token context window.

A reasoning model generates reasoning tokens before its answer. You do not see them, but they occupy space in the context window and are billed as output tokens, and OpenAI recommends reserving at least 25,000 tokens for reasoning and output when you start. That changes cost planning more than any price cut: depending on the problem, the reasoning behind one answer can run from a few hundred to tens of thousands of tokens. How reasoning models reach an answer, and where they still fail, is covered in our post on logical AI.

The o-series has since been folded back in: OpenAI's o3 page names GPT-5 as its successor, and the flagship models on its models page as of September 2026 are GPT-6 Astra, GPT-6 Sol and GPT-6 Luna.

Is GPT-4 Turbo deprecated? Shutdown dates

Yes. On OpenAI's deprecations page, a notice dated April 22, 2026 lists gpt-4-turbo, its snapshot gpt-4-turbo-2024-04-09 and gpt-4-turbo-completions for shutdown on October 23, 2026. The same notice retires the original GPT-4 and the first GPT-4o snapshot on the same day. The full picture for the GPT-4 generation:

OpenAI lists the original DevDay snapshot, gpt-4-1106-preview, in both the September 2025 and the April 2026 notices; either way, it has no future after October 23, 2026.

OpenAI's vocabulary is precise. A model is deprecated the moment its retirement is announced, and every deprecated model has a shutdown date after which it is no longer accessible. Legacy means it gets no more updates and will be deprecated at some point. For generally available models OpenAI promises at least six months' notice; for preview models, those with preview in the name, notice can be as short as two weeks. In some cases developers can arrange dedicated capacity through OpenAI's sales team to keep using a model after its shutdown date.

Azure OpenAI keeps its own schedule. Under Microsoft's lifecycle policy, a generally available model version retires 18 months after launch, subscription owners are notified at least 60 days ahead, and a retired model answers every request with 410 Gone. The model retirement schedule, last updated September 21, 2026, does not list any GPT-4 or GPT-4 Turbo version. The oldest GPT-4o version it lists, 2024-05-13, retires on December 9, 2026, when Standard deployments are upgraded automatically to gpt-5.6-sol; provisioned deployments are not upgraded and must be migrated by hand.

Which model should replace GPT-4 Turbo?

The substitute OpenAI's deprecations page now names is gpt-5.6-sol, the top tier of the GPT-5.6 family released on July 9, 2026: a 1,050,000-token context window, up to 128,000 output tokens and a February 16, 2026 knowledge cutoff. It lists at $4 per million input tokens and $20 per million output tokens, a promotional price OpenAI says runs at least through November 21, 2026.

Since GPT-5.6, OpenAI has released GPT-6: Astra on September 3, 2026, and Sol and Luna on September 22. The GPT-6 Sol page, for example, lists a 1,050,000-token context window and up to 128,000 output tokens per response, more than 30 times GPT-4 Turbo's output limit. Prices from OpenAI's pricing page as of September 25, 2026, standard processing, for prompts up to 272,000 tokens:

Read the table with its footnotes. On GPT-6, prompts over 272,000 input tokens cost twice the input rate and 1.5 times the output rate for the whole request; Batch and Flex processing cost half the standard rate, and Fast mode, the renamed Priority processing, costs double. Regional processing adds 10% for eligible models released on or after March 5, 2026. GPT-5 lists at $1.25 input and $10 output, but its first snapshot shuts down in December.

Per-token prices do not give you the cost of a task. A reasoning model bills its hidden reasoning as output, and OpenAI's own GPT-6 guide argues that Astra's higher per-token price is offset by using fewer output tokens per task. That is a claim to test on your own requests, not one to budget on.

If your GPT-4 Turbo workload is chat, extraction, classification or summarization, start the comparison with the cheaper tiers at low or no reasoning effort: GPT-6 Sol and Luna accept none, while GPT-6 Astra starts at low. Add Astra, or a higher effort setting, only for the cases the cheaper model fails.

How to migrate off GPT-4 Turbo

A model change is a software change. Treat it like one, and finish well before October 23, 2026:

1. Find every call. Search code, configuration and environment files for the old model names. In a Git repository:

   git grep -nE 'gpt-4-turbo|gpt-4-0613|gpt-4-1106|gpt-4-0125|gpt-4o-2024-05-13|"gpt-4"'
   

   Then check what code search misses: Azure OpenAI deployment names, which you choose yourself and may not contain the model name; low-code flows; fine-tuned models built on GPT-4; and vendor products that call GPT-4 Turbo on your behalf.

2. Build an evaluation set before you change anything. Collect real inputs from logs and from the people who handle the work, each with what a good output must contain and a pass rule. Include typical, edge and adversarial cases, as OpenAI's evaluation guide recommends; the same guide lists "vibe-based evals", judging a model by whether it seems to work, as an anti-pattern. Start small and add every production failure to the set.

3. Shortlist candidates: OpenAI's substitute, a cheaper tier, and, if your data terms allow it, a model from another vendor.

4. Pin the model in configuration, not in code. Use a dated snapshot where one exists. OpenAI's text generation guide recommends pinning production applications to specific snapshots and building evaluation suites to watch behaviour when you upgrade. As of September 2026 the GPT-6 model pages list the alias itself, such as gpt-6-sol, as the default snapshot, so record the date you tested and watch the changelog.

5. Update the integration, not only the model name. Replace JSON mode with Structured Outputs where you parse JSON. Move tool calls from Chat Completions to the Responses API, which GPT-6 Astra requires for tool calling. Remove custom temperature, top_p and logprobs for Astra, which does not accept them. Raise the output limit to leave room for reasoning.

6. Run the evaluation set on every candidate and compare pass rate, cost per task and latency. Keep the cheapest model that passes.

7. Roll out in stages and keep a fallback. Send a small share of traffic first and compare it with the old model while that still runs. After the switch, rerun the evaluation set whenever the model, the prompt or the source data changes.

A minimal call with the model name taken from configuration, following the pattern in OpenAI's reasoning guide:

import OpenAI from "openai";

const openai = new OpenAI();

const response = await openai.responses.create({
  model: process.env.OPENAI_MODEL, // the pinned model for this environment
  reasoning: { effort: "low" },
  max_output_tokens: 25000,
  input: "Classify this support email as billing, technical or other: ...",
});

console.log(response.output_text);

How to compare models and vendors without trusting leaderboards

Launch posts and leaderboards answer a different question from yours: which model scored best on someone else's test, under settings the publisher chose. Two recent findings show how far that can drift from real performance.

• Leaderboards reward selective testing. A 2025 study of Chatbot Arena, The Leaderboard Illusion, found that a handful of providers tested many private variants before release and could retract scores; it identified 27 private variants tested by Meta ahead of the Llama 4 release. It also estimated that Google and OpenAI had received 19.2% and 20.4% of all Arena data, against 29.7% for 83 open-weight models combined.
• Benchmarks wear out. In February 2026 OpenAI stopped reporting SWE-bench Verified, a coding benchmark it had created in 2024. In an audited subset of problems that models often failed, at least 59.4% had flawed tests that rejected correct solutions, and every frontier model OpenAI tested could reproduce the reference fix or problem details for some tasks, a sign they had seen them in training.

Our Gemini explainer shows the same problem from another angle: how the prompting method, contamination and shortcuts move a headline score. Microsoft's Azure guidance makes the practical point: test candidate models on your own application and data, and weigh quality, latency and cost together instead of leaning on public benchmarks.

The comparison that predicts your results is the one you run yourself: the same evaluation set, prompts adapted to each vendor's documented style, and the same scoring rules for every candidate.

Keep the evaluation set in your own repository, not in a vendor's dashboard. OpenAI is closing its own hosted Evals platform: existing evals become read-only on October 31, 2026, and the dashboard and API are scheduled to shut down on November 30, 2026. Test cases that live next to your code survive a change of vendor, and so do tools built on open standards such as the Model Context Protocol; our comparison of AI frameworks covers which agent SDKs support it.

If you want this done for a real workflow, our AI automation service builds an evaluation set from your real cases and runs it before any model, prompt or source change goes live; if the scores drop, the change does not ship. Model and prompt versions are pinned, and a fallback model covers a provider outage.