OpenAI Model Deprecation Guide 2026: Migrating from GPT-4o, GPT-4.1 & o4-mini

OpenAI just pulled the plug on several models that a lot of us were still using. GPT-4o, GPT-4.1, GPT-4.1 mini, and o4-mini have all been retired from ChatGPT as of late February 2026. The API side hasn't changed yet, but if you've been through OpenAI deprecation cycles before, you know the pattern: ChatGPT retirements come first, API shutdowns follow within months.

If your production code still references any of these models, now's the time to migrate — not when the API starts returning 404s.

What Got Retired and Why

Here's the full list of models OpenAI removed from ChatGPT in February 2026:

The reasoning is straightforward: OpenAI wants to consolidate around the GPT-5 family. Maintaining multiple model generations costs them compute and engineering resources. Every old model sitting on their infrastructure is a server that could be running GPT-5 instead.

For the API, OpenAI said "no changes at this time." But that's corporate for "not yet." If you're building anything that needs to work six months from now, treat this as your migration warning.

The Migration Map: Which Model Replaces What

Not every GPT-4-era model maps cleanly to a GPT-5 equivalent. Here's how to think about it:

GPT-4o → GPT-5

This is the simplest swap. GPT-5 is better at basically everything GPT-4o did — coding, analysis, creative writing, function calling. The API format is identical. Change the model string and you're done.

# Before
model="gpt-4o"

# After
model="gpt-5"

One thing to watch: GPT-5 is more expensive per token than GPT-4o was. If you were using GPT-4o specifically because it was cheaper than GPT-4 Turbo, you'll want to check the pricing difference for your volume.

GPT-4.1 / GPT-4.1 mini → GPT-5 / GPT-5 mini

GPT-4.1 was OpenAI's attempt at a coding-optimized model. GPT-5 absorbed those improvements and then some. For the mini variant, GPT-5 mini is the direct replacement — similar speed, lower cost, slightly less capable than full GPT-5.

# Before
model="gpt-4.1"       # or "gpt-4.1-mini"

# After
model="gpt-5"         # or "gpt-5-mini"

o4-mini → o5-mini (or GPT-5 with reasoning)

This one's trickier. The o-series models use chain-of-thought reasoning, which works differently from standard chat completions. If you were using o4-mini for its reasoning capabilities, you have two options:

1. Switch to o5-mini — keeps the same reasoning-first approach
2. Switch to gpt-5 with the reasoning parameter — GPT-5 now supports optional extended thinking

The second option gives you more control. You can toggle reasoning on or off per request, which means you're not paying for chain-of-thought tokens on simple queries.

Code Changes You'll Actually Need to Make

For most apps, migration is literally a string replacement. But there are a few edge cases that'll bite you if you're not careful.

1. Check your model string handling

If your code does any model-name parsing (like checking if the model starts with "gpt-4"), update those conditions:

# Bad — breaks when you switch to gpt-5
if model.startswith("gpt-4"):
    max_tokens = 8192

# Better — use a config dict
MODEL_CONFIGS = {
    "gpt-5": {"max_tokens": 16384, "supports_vision": True},
    "gpt-5-mini": {"max_tokens": 8192, "supports_vision": True},
}

2. Update max_tokens defaults

GPT-5 supports longer outputs than GPT-4o did. If you had hardcoded max_tokens=4096 as a safety limit, you might want to increase it — or better yet, use max_completion_tokens which is the newer parameter name OpenAI prefers.

3. Function calling schema changes

GPT-5 handles function calling (tool use) slightly differently than GPT-4o. The format is the same, but GPT-5 is stricter about JSON schema validation. If you had sloppy schemas that GPT-4o tolerated, GPT-5 might reject them. Test your function definitions.

# Make sure your tool schemas are valid JSON Schema
tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "City name"
                }
            },
            "required": ["city"],
            "additionalProperties": False  # GPT-5 respects this strictly
        }
    }
}]

4. Vision input format

If you were using GPT-4o's vision capabilities, GPT-5 uses the same message format for images. No changes needed here — just verify your image URLs or base64 payloads still work after the model swap.

Testing Your Migration

Don't just swap the model string and deploy. Here's a practical testing approach:

1. Run your existing test suite against GPT-5 with the same prompts
2. Compare output quality — GPT-5 is generally better, but "different" can still break downstream parsing
3. Check latency — GPT-5 might be slightly slower for complex queries due to its larger architecture
4. Monitor token usage — GPT-5 tends to be more verbose, which means higher costs if you're not setting output limits
5. Test edge cases — especially function calling, JSON mode, and any structured output you depend on

A quick way to A/B test without changing production:

import random

def get_model():
    # 10% traffic to GPT-5 for testing
    if random.random() < 0.1:
        return "gpt-5"
    return "gpt-4o"  # still works on API for now

What If You Don't Want to Depend on One Provider?

This deprecation cycle highlights a real problem: if your entire stack depends on OpenAI's model naming and availability, you're at their mercy every time they retire something.

One way to insulate yourself is to use an OpenAI-compatible API gateway that supports multiple providers. You write your code against the OpenAI format once, and the gateway handles routing to whichever model you choose — GPT-5, Claude Sonnet 4.6, or anything else.

With a gateway like KissAPI, switching from a deprecated model to its replacement (or to a completely different provider) is a config change, not a code change:

from openai import OpenAI

# One client, any model
client = OpenAI(
    api_key="your-key",
    base_url="https://api.kissapi.ai/v1"
)

# GPT-5
response = client.chat.completions.create(
    model="gpt-5",
    messages=[{"role": "user", "content": "Hello"}]
)

# Claude Sonnet 4.6 — same code, different model string
response = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[{"role": "user", "content": "Hello"}]
)

When the next deprecation hits (and it will), you just update the model string. No SDK changes, no endpoint changes, no vendor lock-in panic.

Timeline: How Long Do You Have?

Based on OpenAI's historical pattern:

• ChatGPT retirement → API deprecation notice: usually 1-3 months
• API deprecation notice → actual shutdown: usually 3-6 months
• Total window from ChatGPT retirement to API death: roughly 6-9 months

So if GPT-4o was retired from ChatGPT in February 2026, expect the API deprecation notice around March-May 2026, with final shutdown sometime in late 2026. That sounds like plenty of time, but migrations always take longer than you think — especially if you have multiple services using the old models.

Start now. Your future self will thank you.

Quick Migration Checklist

1. Audit your codebase for all references to gpt-4o, gpt-4.1, gpt-4.1-mini, and o4-mini
2. Map each usage to the appropriate GPT-5 family model
3. Update any model-name parsing logic
4. Review and tighten your function calling schemas
5. Run your test suite against the new models
6. Monitor costs for the first week — GPT-5 token pricing differs
7. Consider a multi-provider gateway to avoid this problem next time

Model deprecations are annoying, but they're also an opportunity to clean up technical debt and rethink your AI infrastructure. The teams that handle this well are the ones that already abstracted their model layer. If you haven't done that yet, now's a good time to start.