Skip to content

OpenAI shuts down GPT-4o and GPT-4.1 on January 14, 2027, Anthropic retires Claude Sonnet 4.5 on November 30, and Google silently reroutes Gemini 2.5 from December 1. The full calendar, how products break when a model goes away, and how to migrate so you end up paying less.

Published
Reading
13 min
Author
Yaroslav Tsarenko
–views
Glowing nodes on a dark field: some fade out while their lines smoothly switch over to new bright points

On October 14, 2026, OpenAI emailed developers: GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini stop working in the API on January 14, 2027 (OpenAI deprecations page). These are the models behind thousands of chatbots, support assistants, description generators and internal tools built over the last two years. And it is not the only date this winter: Anthropic and Google are retiring models too.

This article is for founders and product teams with AI features in their product — especially features built quickly with Lovable, Bolt or Cursor, or by a contractor who has since moved on. We'll go through what is being switched off and when, the three ways a product breaks when a model disappears (one of them silent), how to find old models in your code in 15 minutes, and how to migrate so you end up with a smaller AI bill, not just a working one.

What's being retired, and when: the next 90 days

Retiring models is routine for AI providers: new models need capacity, old ones get removed. But in autumn 2026 the dates landed unusually close together.

What's being switched off nextNov 17GoogleGemini 2.5 TTS and live previewsNov 30AnthropicClaude Sonnet 4.5Nov 30OpenAIEvals, Agent Builder, v1/promptsDec 1GoogleGemini 2.5 Pro and Flash → silent swapDec 1OpenAIgpt-image-1-mini, gpt-image-1.5Dec 11OpenAIgpt-5, gpt-5-mini, gpt-5-nano, o3Jan 6OpenAItts-1, tts-1-hd, gpt-4o-mini-ttsJan 14OpenAIGPT-4o, 4o mini, GPT-4.1, 4.1 miniFeb 26OpenAIwhisper-1, gpt-4o transcription
Date Provider What stops working Recommended replacement
Nov 17, 2026 Google gemini-2.5-flash-preview-tts, gemini-2.5-pro-preview-tts and live-audio preview models gemini-3.8-flash-tts, gemini-3.8-live
Nov 30, 2026 Anthropic claude-sonnet-4-5-20250929 claude-sonnet-5-5
Nov 30, 2026 OpenAI Evals, Agent Builder and reusable prompts (v1/prompts) prompts in code, Agents SDK, Promptfoo
Dec 1, 2026 Google gemini-2.5-pro and gemini-2.5-flash — requests are routed to newer models automatically gemini-3.8-flash, gemini-3.5-flash-lite
Dec 1, 2026 OpenAI gpt-image-1-mini, gpt-image-1.5 gpt-image-2.5-sunburst or -flare
Dec 11, 2026 OpenAI gpt-5, gpt-5-mini, gpt-5-nano, gpt-5-pro, o3, o3-pro gpt-5.6-sol, -terra or -luna
Jan 6, 2027 OpenAI tts-1, tts-1-hd, gpt-4o-mini-tts gpt-realtime-2.1-mini
Jan 14, 2027 OpenAI GPT-4o, GPT-4o mini, GPT-4.1, GPT-4.1 mini gpt-6-luna
Feb 26, 2027 OpenAI whisper-1 and gpt-4o-based transcription gpt-transcribe, gpt-live-transcribe

Sources: the deprecation pages of OpenAI, Anthropic and the Google Gemini API. Google's dates are the "earliest possible" retirement dates, so they may move — but planning around a delay is a bet, not a plan.

One change is already live: in Anthropic API version 2026-10-21, the temperature, top_p and top_k parameters were removed entirely, and a request that sends them gets a 400 error (same page, parameter section). If your code passes temperature: 0.7 out of habit, it can start failing after an SDK upgrade.

Why this affects you even if "nobody touched the AI"

The most common thing I hear is: "the AI just works, we haven't changed anything." That is exactly why it's worth checking. A model name usually ends up in a product in one of four places:

  • in code — model: "gpt-4o" inside a function written a year ago;
  • in environment variables — OPENAI_MODEL=gpt-4o-mini on the host, which nobody remembers setting;
  • in no-code automations — an "OpenAI" step in Zapier, Make or n8n with a model picked from a dropdown;
  • inside third-party tools — a chat widget, CRM or builder that calls a model with your API key.

Apps generated with AI tools are especially exposed: the generator writes whatever model was popular at the time and repeats it in every file that makes a call. Other things that tend to sit below the waterline in such products are covered in 10 signs your vibe-coded MVP needs a developer.

Three ways a product breaks

A model retirement doesn't always look like an outage. There are three scenarios, and the second one is the nastiest.

1Loud errorThe request fails,the AI featurestops workingSeen at once2Silent swapAnother modelanswers now: newstyle and formatCustomers notice3Behaviour driftAfter a renamethe new modelbehaves differentlyCaught by evals

1. A loud error. After the shutdown date, a request to the model returns an error. The chatbot goes quiet, description generation stops, the logs fill with the same error. Painful, but at least you see it immediately.

2. A silent swap. From December 1, 2026, Google doesn't switch off gemini-2.5-pro and gemini-2.5-flash; it routes requests to newer models instead. Nothing crashes, but a different model is now answering — with a different style, length and failure modes. If your code parses the answer as JSON or looks for particular words in it, something can break quietly, and you'll hear about it from customers.

3. Behaviour drift after a "simple" swap. You replaced gpt-4o with a new model, and everything works — differently. OpenAI's newer models lean toward long answers with lists and tables, and on GPT-6 Astra, Sol and Terra tool calling only works through the Responses API (OpenAI migration guide). temperature and top_p must be removed when reasoning is on. Code that ran for two years on Chat Completions may need rewriting, not just renaming.

The good news: newer models are cheaper

It's easy to see a migration as pure cost. In practice it's a chance to cut your AI bill, because prices have fallen a lot over the past year.

$ per 1M output tokens (input in brackets)GPT-4o10.00 (2.50)GPT-4.18.00 (2.00)GPT-6.1 Terra5.00 (1.00)GPT-4.1 mini1.60 (0.40)GPT-4o mini0.60 (0.15)GPT-6 Luna0.50 (0.10)retiringnew
Model Input, $ per 1M tokens Output, $ per 1M tokens
GPT-4o (retiring) 2.50 10.00
GPT-4.1 (retiring) 2.00 8.00
GPT-4.1 mini (retiring) 0.40 1.60
GPT-4o mini (retiring) 0.15 0.60
GPT-6.1 Terra 1.00 5.00
GPT-6 Luna 0.10 0.50

Standard-tier prices from OpenAI's pricing page as of early November 2026. GPT-6.1 Terra was released on October 26 (OpenAI changelog).

A rough illustration. Say your assistant processes 10M input and 2M output tokens a month:

  • on GPT-4o that is $25 + $20 = $45 a month;
  • on GPT-6.1 Terra, $10 + $10 = $20;
  • on GPT-6 Luna, $1 + $1 = $2.

That's list-price arithmetic, not a promise: a cheaper model may not handle your task, and a newer one may write longer answers and burn more output tokens. The decision comes after a comparison on your real requests, described below. But the orders of magnitude show why, for many products, the migration pays for itself in the first month.

Find the retiring models in your product in 15 minutes

Start with an inventory: every place your product calls a model, and which model it names.

1. Search the code. If you have the repository, this small TypeScript script lists model names that are about to be retired:

ts
// find-retiring-models.ts — run: npx tsx find-retiring-models.ts
import { readdirSync, readFileSync, statSync } from "node:fs";
import { join } from "node:path";

const retiring: Record<string, string> = {
  "gpt-4o": "2027-01-14",
  "gpt-4.1": "2027-01-14",
  "gpt-5-mini": "2026-12-11",
  "gpt-5-nano": "2026-12-11",
  "o3": "2026-12-11",
  "claude-sonnet-4-5": "2026-11-30",
  "gemini-2.5-": "2026-12-01",
  "whisper-1": "2027-02-26",
  "tts-1": "2027-01-06",
};
const skip = new Set(["node_modules", ".git", ".next", "dist", "build"]);

function walk(dir: string, out: string[] = []): string[] {
  for (const name of readdirSync(dir)) {
    if (skip.has(name)) continue;
    const path = join(dir, name);
    if (statSync(path).isDirectory()) walk(path, out);
    else if (/\.(ts|tsx|js|jsx|py|json|ya?ml|env|toml)$|^\.env/.test(name)) out.push(path);
  }
  return out;
}

for (const file of walk(process.cwd())) {
  readFileSync(file, "utf8").split("\n").forEach((line, i) => {
    for (const [model, date] of Object.entries(retiring)) {
      if (line.includes(model)) console.log(`${file}:${i + 1}  ${model} → retires ${date}`);
    }
  });
}

The output looks like this:

bash
src/lib/ai/chat.ts:14  gpt-4o → retires 2027-01-14
src/lib/ai/summary.ts:8  gpt-4.1 → retires 2027-01-14
.env.example:3  gpt-4o → retires 2027-01-14

The gpt-4o pattern also matches gpt-4o-mini on purpose — both are retired on the same day. The o3 pattern is deliberately broad; expect a few false positives and skim them.

2. Environment variables. Open your host's settings (Vercel, Render, Railway and so on) and look for variables containing MODEL, OPENAI, ANTHROPIC or GEMINI.

3. No-code and third-party tools. Go through your Zapier, Make or n8n scenarios and any integration you gave an API key to.

4. Usage data. Anthropic lets you export usage broken down by API key and model under Usage → Export in the console (Anthropic's instructions), and OpenAI's usage dashboard also shows spend per model. If you see spend on a model that isn't in your code, something you forgot about is calling it.

Migrating without surprises: a four-week plan

The worst way to migrate is to change the model name on a Friday evening and deploy. The best way looks like this:

  1. day 1
    Inventoryevery place a model is named: code, env vars, no-code flows
  2. week 1
    Eval set20–50 real requests with the answer you expect
  3. week 2
    Comparequality, format, latency and cost on old and new models
  4. week 3
    Gradual rollout5% → 50% → 100% of traffic, one switch to roll back
  5. week 4
    Clean upold model names and parameters removed, alerts in place
Migrating a model in 4 weeks without surprises

The eval set is the core of it. Collect 20–50 real production requests (with personal data removed) and write down what a correct answer looks like for each: required JSON fields, the right category, no invented facts. Run the set through the old and the new model and you'll see the difference in numbers rather than impressions. Ready-made tools exist, for example Promptfoo — which is also the migration path OpenAI points to for its own Evals product, closing on November 30.

Compare four things: quality (how many checks pass), format (does parsing still work), latency (time to first token and to full answer) and cost (tokens per request). Often a cheaper model handles most requests and the expensive one is only needed for the hard ones — then you route them separately.

Switch gradually. Send 5% of traffic to the new model, then half, then all of it. Keep a one-switch rollback while the old model is still alive.

What changes in the code: an example

Here's a typical GPT-4o call through Chat Completions, and the same feature on a new model through the Responses API with a validated answer:

ts
// Before: model hard-coded in the call, answer never validated
const res = await openai.chat.completions.create({
  model: "gpt-4o",
  temperature: 0.7,
  messages: [{ role: "user", content: `Classify this ticket: ${text}` }],
});
const category = res.choices[0].message.content;
ts
// After: model from config, structured output, schema check
import OpenAI from "openai";
import { z } from "zod";

const MODELS = { classify: process.env.AI_MODEL_CLASSIFY ?? "gpt-6-luna" } as const;
const Category = z.object({ category: z.enum(["billing", "bug", "sales", "other"]) });

export async function classify(text: string) {
  const res = await new OpenAI().responses.create({
    model: MODELS.classify,
    input: `Classify this customer ticket: ${text}`,
    text: {
      format: {
        type: "json_schema",
        name: "category",
        strict: true,
        schema: {
          type: "object",
          properties: { category: { type: "string", enum: ["billing", "bug", "sales", "other"] } },
          required: ["category"],
          additionalProperties: false,
        },
      },
    },
  });
  return Category.parse(JSON.parse(res.output_text));
}

Three changes matter more than the model name. The model lives in one place (config or an environment variable), so the next migration is one line. The answer has a strict schema, so if a new model returns something else you get a clear error instead of a silent break. And temperature is gone, as newer reasoning models require.

An architecture that survives the next wave

This wave won't be the last. Anthropic commits to at least 60 days' notice before retiring publicly released models (Anthropic's policy); at OpenAI the gap between the email and the shutdown is usually three to six months. Migrations are becoming routine, so make them cheap.

Product featuresCustomer chatClassificationSummariesAI layermodel config per taskeval set in CIfallback modelspend limits, alertsProvidersOpenAIAnthropicGoogle

Hard-coded

  • Model name in 12 filesevery migration is a codebase-wide search
  • No checkscustomers notice quality changes first
  • One provideran outage or retirement stops the feature

One layer

  • One model configa migration is one line and a deploy
  • Eval seta new model passes tests before release
  • Fallback modelautomatic switch when errors pile up
Model hard-coded vs. one layer for all AI calls

The minimum I build into products with AI features:

  • one layer for every model call — the product doesn't know which model or provider sits behind it;
  • a model config per task — "classify", "reply to customer", "summarise", each with its own model;
  • an eval set in CI — it runs whenever a prompt or model changes;
  • a fallback model — if the primary one errors, the request goes to another, possibly from another provider;
  • spend limits and alerts — at the provider and in your own monitoring;
  • someone reads the changelogs — checking three providers' deprecation pages once a month takes 10 minutes.

On the AllShip AI marketplace, the assistant works through tools and never acts on its own: every action that changes data goes through a confirmation. That design helps with migrations as well — when a model's behaviour shifts, the limits of what it is allowed to do stay exactly the same. I wrote more about grounding answers in real data and keeping costs predictable in OpenAI API in production: logistics lessons.

If a contractor or a SaaS runs your AI: what to ask

Not everyone writes the code themselves. Often the AI feature was built by an agency or a freelancer, or it's part of a SaaS you pay for every month. Then the migration is their job, but the risk is yours. Here are five questions worth sending this week:

  1. Which models does our product use, and for which features? A good answer is a concrete list of model names, not "the latest OpenAI models".
  2. Are we affected by the November 30, December 1, December 11 and January 14 retirements? If the answer is "we'll check", ask for the date they'll have checked by.
  3. How will you make sure the new model is not worse? Look for an eval set or a side-by-side comparison, not "we'll test it manually".
  4. What happens to cost? If you pay for AI usage separately from the subscription, moving to a cheaper model is a reason to revisit the invoice.
  5. Is there a fallback if the provider goes down? Even a simple "yes, we switch to another model" beats silence.

If a contractor can't name the models your product uses, that's a bigger warning sign than any shutdown date. It means nobody owns this part of the system, and the next change on the provider's side will be a surprise again. In that case it's worth getting an independent look at the code, at least once, and at how AI calls are wired into it.

No-code automations deserve their own check. Zapier, Make and n8n usually don't switch the model for you: a step keeps whatever model was selected when it was set up. Open every scenario with an AI step and check which model it uses — ten minutes now beats discovering in January that a flow stopped working quietly weeks ago.

There is also a quieter cost of waiting. Provider support and documentation shift to the new models first, and SDK releases start dropping old parameters. The longer a product stays on a retiring model, the more small incompatibilities pile up, and the bigger the final jump becomes.

If your users are in the EU, add one more question to the list: does the new model still mark generated content and does your product still tell people they're talking to AI? Since August 2, 2026 that's a legal duty, and the deadline for older products is December 2; I covered it in EU AI Act Article 50.

Do it yourself or bring in a developer

Situation What to do
1–2 model calls, plain text output, you have the code Swap the model yourself, check 20 requests by hand
The answer is parsed as JSON or affects money, statuses or access Build an eval set and roll out gradually; worth bringing in a developer
The model is hard-coded in many places, no tests, code written by AI or by a contractor who's gone Start with an audit: find every call, move them into one layer, then migrate
AI is the core of the product (assistant, agent, customer-facing generation) A full plan: evals, 2–3 candidate models compared, staged rollout, a fallback provider

If your product was generated with AI tools and nobody is sure where the models are called, that's exactly where a short audit saves weeks. How I build and migrate these integrations is on the AI integration page. And since you'll be touching AI configuration anyway, it's a good moment to rotate old keys — see what the LiteLLM and Railway leaks taught us.

Checklist for this week

  • Find every place your product calls a model: code, env vars, no-code flows, third-party tools.
  • Match each model against the calendar above and note its date.
  • Check whether your code sends temperature or top_p to Anthropic models or newer OpenAI models.
  • Collect 20–50 real requests with the answers you expect.
  • Compare the old model with 1–2 candidates on quality, format, latency and price.
  • Move model names into a single config.
  • Schedule the switch at least two weeks before the shutdown date.
  • Set a spend limit and an alert on provider errors.

What to do today

Run the code search and check your environment variables. It takes 15 minutes, and afterwards you'll know whether January 14 affects you. If it does, you still have time to migrate calmly — with checks, gradually, and with a chance to shrink your AI bill. With a week left, the same work gets done in a rush.

Was this useful?

– likes · – views

Need this for your product?AI features grounded in your data, not a chat widget glued onLearn more →

Questions people ask

When is GPT-4o being shut down?

On January 14, 2027. GPT-4o (gpt-4o-2024-08-06 and gpt-4o-2024-11-20), GPT-4o mini, GPT-4.1 and GPT-4.1 mini all stop working in the API that day. OpenAI announced it on October 14, 2026 and recommends gpt-6-luna as the replacement; for harder tasks it is worth comparing gpt-6.1-terra too.

What happens to my app if I do nothing?

After the shutdown date, requests to the retired model return an error, so the AI feature simply stops working. Google is different: from December 1, 2026, requests to gemini-2.5-pro and gemini-2.5-flash are scheduled to be routed to newer models automatically, so nothing crashes, but the answers can change without warning.

Can I just change the model name in the code?

Sometimes, but it is risky. Newer models format answers differently, some parameters are gone (temperature, for example, when reasoning is on), and tool calling on GPT-6 Astra, Sol and Terra requires the Responses API. It is safer to run 20–50 real requests through the new model and compare the results before switching.

Will AI get cheaper after migrating?

Usually, yes. On OpenAI's price list GPT-4o costs $2.50 per million input tokens and $10 per million output tokens, GPT-6.1 Terra costs $1 and $5, and GPT-6 Luna $0.10 and $0.50. How much you actually save depends on which model passes your quality checks.