OpenAI Retires GPT-4 and o1 on Oct 23: Your Migration Plan

OpenAI announced this wave on April 22, 2026, and the date is ten days away. Any request that names one of these models will start failing on October 23. Not slowly, not with a warning header. It fails.

Here is the list from OpenAI's deprecations page, grouped by the replacement OpenAI recommends:

• Moving to gpt-5.6-sol: gpt-4-0613 (the plain "gpt-4" alias), gpt-4-1106-preview, gpt-4-turbo, gpt-4o-2024-05-13, o1, o1-pro (in pro reasoning mode) and o3-mini.
• Moving to gpt-5.6-terra: gpt-3.5-turbo-0125, o4-mini and the fine-tuned o4-mini.
• Moving to gpt-5.6-luna: gpt-4.1-nano.
• Fine-tuned models: ft-gpt-3.5-turbo, ft-gpt-4, ft-gpt-4.1-nano, ft-babbage-002 and ft-davinci-002. OpenAI's suggested path is the matching base model, which means your fine-tune does not carry over.
• Images: gpt-image-1, replaced by gpt-image-2.5-sunburst or gpt-image-2.5-flare.

Read that list against your code, not against your memory. Plenty of teams are sure they "moved to the new stuff last year" and then find a pinned snapshot string in a cron job, a Zapier step or a staging config that nobody has opened since.

One detail that trips people up: the date applies to specific snapshots. The base gpt-4o name is not on this list. The dated snapshot gpt-4o-2024-05-13 is. If your code pins a snapshot, you are exposed. If it uses a floating alias, check what that alias points to today before you assume you are safe.

You cannot migrate what you cannot find. The inventory is the part founders skip, and it is the part that causes the 2 a.m. incident on October 23.

Search in five places:

1. Your codebase. Grep for the model strings: "gpt-4", "gpt-3.5", "o1", "o3-mini", "o4-mini", "gpt-4.1-nano", "davinci", "babbage". Include test fixtures, seed scripts and notebooks. Notebooks are where old model names go to hide.
2. Environment variables and config. A lot of teams keep the model name in an env var like MODEL_NAME. Your repo will look clean while production is pinned to a dead snapshot. Check the actual values in your hosting dashboard.
3. No-code and automation tools. Zapier, Make, n8n, Retool and internal admin panels often call OpenAI directly with a model picked by whoever built the flow.
4. Third-party vendors. Ask your support-desk tool, your CRM add-ons and your analytics vendor which model they call on your behalf. Most will tell you they are handling it. Get that in writing, with the date.
5. Your usage dashboard. OpenAI's usage breakdown by model shows what has actually been called in the last 30 days. It is the ground truth. If a deprecated model shows traffic, something is calling it, and you need to know what.

Write the result in a plain table: call site, model string, what the feature does, who owns it, how much traffic it gets. For most startups this is 5 to 20 rows. For a product with years of AI features layered on it, 40 is not unusual. Either way it is half a day of work, and it tells you how big the real job is.

Sort the table by traffic and by customer visibility. The chat feature your users touch daily gets the careful treatment. The internal script that summarizes support tickets on Fridays gets a model swap and a quick look.

OpenAI lists a replacement for each retired model. That is a recommendation about capability, not a promise that your prompts behave the same. Treat the swap like a dependency upgrade across a major version, because that is what it is.

Here is what changes in practice.

Output style and length

Newer models tend to be more verbose or more terse than the ones they replace, and it varies by prompt. A prompt that produced a clean two-sentence answer on GPT-4 Turbo may now produce a paragraph with caveats. If your UI has a fixed-height card, that matters. If a downstream parser expects a specific format, it matters a lot.

Structured output and tool calling

If you depend on JSON that matches a schema, test it hard. Older models needed coaxing and your prompt may carry workarounds that now fight the new model. Remove the hacks one at a time and rerun your tests. If you are still parsing JSON out of free text, this migration is the moment to move to proper structured outputs.

Reasoning models behave differently

The o1, o3-mini and o4-mini family spent hidden reasoning tokens before answering. The replacements have their own reasoning controls, and the cost and latency profile is not identical. A request that took 4 seconds and cost a few cents may take 2 seconds or 9, depending on the settings you pick. Do not assume. Measure.

Parameters that no longer apply

Some sampling parameters and legacy request fields are ignored or rejected by newer models. A request that worked for two years can start returning a 400 because of a parameter nobody remembers adding. Read the API reference for the target model, not just the migration notice.

Cost

Per-token prices on the successor models differ from the originals, and with reasoning models the token count per request differs too. Some features get cheaper. Some get more expensive. Check current pricing on OpenAI's pricing page this week and run your real traffic shape through it. Do not trust a blog post, including this one, for the exact numbers.

The single best use of your next two days is a small, honest test set. You do not need a platform. You need 50 to 200 real inputs and a way to judge the outputs.

Pull the inputs from production logs. Pick them on purpose:

• The common cases, because they carry most of the volume.
• The ugly cases: long inputs, messy inputs, non-English inputs, empty fields.
• The cases where the model once got something wrong and you fixed the prompt. These are your scar tissue, and they regress first.
• The cases where a wrong answer costs money or trust: refunds, medical wording, legal wording, anything with a number in it.

Run the old model and the new model on the same inputs. Then judge. For tasks with a right answer (classification, extraction, routing), score automatically against labels. For open-ended text, use a mix: a rubric graded by a stronger model, plus a human read of 20 to 30 outputs. Human spot checks catch things rubrics miss, like a tone that is suddenly cold or an answer that is correct but twice as long.

If you have never set this up, our guide on how to run LLM evaluations walks through the mechanics. The short version is that a spreadsheet and a script beat no test at all, and you can graduate to a proper tool later.

Decide your pass bar before you look at results. Something like: accuracy within two points of the old model, no new failures in the high-stakes set, p95 latency no worse than 20 percent slower, cost per request inside a number the business has agreed to. If you set the bar after seeing the numbers, you will talk yourself into whatever the numbers say.

OpenAI points almost everything at gpt-5.6-sol, which is its top tier in this family. That is the safe pointer for OpenAI, and it is not always the right answer for you.

Think in tiers. The three names line up roughly as a large model, a mid-size model and a small fast one. Sol is the large one, Terra sits in the middle and Luna is the small one. The mapping OpenAI published sends GPT-4-class models to Sol, the o4-mini and 3.5-class models to Terra, and the nano model to Luna.

That mapping is a starting point. Test one tier down from what OpenAI recommends for every high-volume feature. A lot of GPT-4 Turbo workloads were doing summarization, classification or extraction that a mid-tier model handles fine today. Moving those to Terra instead of Sol can cut your bill noticeably, and your regression set will tell you whether quality holds.

Also consider whether OpenAI should be the answer at all. A forced migration is a rare moment when you are already touching every call site, already writing tests and already explaining the change to your team. If you have been meaning to try Claude or Gemini for a workload, now costs less than later. We have written about routing requests across models to cut cost, and a deprecation is a natural time to introduce that layer.

My opinion, for what it is worth: do not switch providers and models in the same week for your most important feature. Move that feature to the recommended OpenAI successor first, ship it, then evaluate alternatives on the calmer side of the deadline. For the low-stakes features, experiment freely.

If you fine-tuned GPT-3.5, GPT-4, GPT-4.1 nano, babbage or davinci, your situation is worse than everyone else's on this list. OpenAI's guidance points to the base model of the successor. That means the behavior you paid to train is gone on October 23 unless you rebuild it.

Work through it in order:

1. Ask whether you still need the fine-tune. Many were trained in 2023 or 2024 to get consistent format or tone out of models that struggled. Current base models follow instructions far better. A good system prompt plus a few examples in the request often matches the fine-tune. Test that first.
2. If you need it, check whether the successor can be fine-tuned. Availability varies by model, so confirm in OpenAI's fine-tuning docs before you plan around it. If it can, retrain on your original dataset. Your training data is the asset, not the weights.
3. Find your training data. If the person who built the fine-tune left, the JSONL file may be on a laptop. Look now. Without it, you are rebuilding from production logs.
4. Budget the evaluation, not just the training. The retrain is cheap. Proving the new fine-tune is as good as the old one is where the hours go.

If you cannot finish a retrain and eval by October 23, ship an interim fix: base model plus a prompt with examples, behind a flag, with a note to revisit. A slightly worse answer on October 23 beats a failed request.

With ten days left you do not have time for a leisurely canary, but you do have time for a sane one. Here is the sequence I would use for a production app with real customers.

1. Days 1 to 2: inventory, regression set, pick candidate models.
2. Days 3 to 4: run the evals, tune prompts, fix parameter errors, settle on a model per feature.
3. Days 5 to 6: put the new model behind a feature flag. Turn it on for internal users and a small slice of customers, around 5 percent.
4. Days 7 to 8: watch error rates, latency, cost per request and support tickets. Widen to 25, then 50 percent if clean.
5. Day 9: go to 100 percent. Keep the old model as a fallback until the shutdown, since it still works until the 23rd.
6. Day 10: remove the old model strings, delete the fallback and confirm in the usage dashboard that no deprecated model shows traffic.

The flag matters more than anything else on this list. If the new model misbehaves at 25 percent, you flip back in a minute. Without a flag, you are redeploying under pressure.

Log the model name on every request, along with latency, token counts and a request id. When a customer says "the assistant got weird on Tuesday," you want to answer with data. If you do not have this logging, add it as part of this migration. It pays for itself the next time a provider changes something.

This will happen again. OpenAI has more retirements scheduled for November and December, including the original GPT-5 snapshots on December 11, and Anthropic and Google retire models on their own calendars. A model name in your code is a dependency with an expiration date. Manage it like one.

A short list of habits that turn the next one into a routine ticket:

• One place for model names. A config file or a small wrapper, not strings scattered through 30 files. The change should be a one-line diff.
• A model registry in your docs. Feature, model, owner, and the provider's published shutdown date. Review it quarterly.
• A standing eval set that runs in CI. When a provider announces a deprecation, you run the suite against the successor the same day and know where you stand.
• A fallback route. If a provider degrades or retires something, a second model you have already tested can take the traffic. Our piece on designing failover when your AI provider goes down covers the pattern.
• A calendar alert. Subscribe to each provider's deprecation feed and set an alert 90 days before every shutdown date that touches you. Ninety days is enough to do this properly. Ten days is not.

The teams that handle these well are not smarter. They have a test set, a flag and a list. Those three things take a week to build once and save weeks every year after.

If you are staring at this deadline with a codebase you do not fully understand, or an AI feature that someone built quickly and nobody owns, we do this kind of migration and cleanup for founders regularly. We can audit your call sites, build the regression set and ship the swap behind a flag. Book a free strategy call and bring your inventory table, even if it is half empty.