GPT-4o and GPT-4.1 API Shutdown (Jan 14, 2027): Migration Guide to GPT-6 Luna

GPT-4o and GPT-4.1 have outlived most of their peers. GPT-4o launched on May 13, 2024. GPT-4.1 followed on April 14, 2025 as an API-only family aimed at developers. Both were removed from ChatGPT on February 13, 2026 and stayed available in the API. That API access now has a fixed end date.

The notice is shorter than usual. According to The New Stack, OpenAI's own deprecation policy promises at least six months' notice for generally available models, and this announcement gives about three. Fine-tuning has its own earlier deadline: OpenAI stops new self-serve fine-tuning jobs on January 6, 2027, eight days before the base models retire.

This guide covers exactly what shuts down and when, what happens to fine-tuned models, how GPT-6 Luna behaves differently, and a migration checklist you can run in a sprint. It also includes the rest of OpenAI's deprecation calendar for the next few months, because many teams have more than one of these deadlines to deal with.

What shuts down on January 14, 2027

The first four rows below are the snapshots and replacements as listed on OpenAI's deprecations page (announced 2026-10-14). The fine-tuned row is our summary of the page's note that fine-tunes follow their base model's schedule.

Two older siblings are already gone. The original gpt-4o-2024-05-13 snapshot and gpt-4.1-nano / gpt-4.1-nano-2025-04-14 were part of an April 22, 2026 notice and shut down on October 23, 2026. If you see errors on those IDs today, that's why.

The deprecations page lists dated snapshots. The New Stack reads the notice as covering the four models "along with their dated snapshots and every fine-tuned model built on top of them." The safe assumption is that the undated aliases (gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini) stop working too, so grep for them as well as for the dated IDs. You can confirm per model by calling GET /v1/models and checking each model's optional shutdown_date field, which OpenAI's deprecations page documents.

What about Azure OpenAI?

Azure runs on its own schedule. Microsoft's model retirement schedule (last updated September 23, 2026, before OpenAI's announcement) lists April 14, 2027 as the retirement date for gpt-4o 2024-08-06 and 2024-11-20, gpt-4o-mini 2024-07-18, gpt-4.1 2025-04-14 and gpt-4.1-mini 2025-04-14. It names gpt-5.1 as the replacement for GPT-4o, lists no replacement for the others, and doesn't mention GPT-6 Luna yet. Azure fine-tuned deployments of these models have later dates on the same page: October 1, 2027 for GPT-4o and GPT-4o mini, and October 14, 2027 for GPT-4.1 and GPT-4.1 mini.

Microsoft's lifecycle and support policy says the official replacement model is "selected and declared approximately 90–120 days before the retiring model's retirement date," so expect the Azure page to change. If you run on Azure, check it again before you plan around these dates. Don't assume the OpenAI date applies to you, and don't assume the Azure date will hold.

What happens to fine-tuned GPT-4o and GPT-4.1 models

This part of the announcement hurts the most. OpenAI's deprecations page says: "Fine-tuned versions of these models follow the same shutdown schedule as their underlying base models." A fine-tuned gpt-4o-2024-08-06 or gpt-4.1-2025-04-14 stops serving on January 14, 2027.

That deadline lands at the end of a separate wind-down of self-serve fine-tuning, which OpenAI announced on May 7, 2026:

• May 7, 2026: organizations that had never run fine-tuning lost the ability to create jobs.
• July 2, 2026: job creation became unavailable to organizations that hadn't run inference on a fine-tuned model in the previous 60 days.
• January 6, 2027: active existing customers can no longer create new fine-tuning jobs.
• Inference on existing fine-tunes is disabled "only when the underlying base model is deprecated." For these models, that's January 14, 2027.

GPT-6 Luna doesn't support fine-tuning (per its model page), so a fine-tuned model has no like-for-like successor on OpenAI's API. Your realistic options:

1. Move the fine-tune's behavior into the prompt. Turn your training set into a compact instruction block plus a handful of curated few-shot examples. Luna's 1,050,000-token context window and $0.01 cached input rate make long, stable system prompts affordable, especially with prompt caching.
2. Retrieve the examples you need. If the fine-tune encoded domain knowledge or a large style corpus, index the training examples and fetch the most similar ones for each request.
3. Raise reasoning effort selectively. Some fine-tunes existed only because a non-reasoning model couldn't follow complex formatting or classification rules reliably. A little reasoning effort on Luna may recover that quality without any training.
4. Fine-tune elsewhere. If you need trained weights for compliance, latency or very narrow output formats, look at a provider or open-weight model that still supports fine-tuning. Azure, for example, lists later deployment-retirement dates for fine-tuned GPT-4o and GPT-4.1 models, but training there is limited to existing customers, and it only buys time before the next migration.

Whichever path you pick, start with the eval set (see the checklist below). You can't tell whether a prompt-only Luna setup matches your fine-tune without the fine-tune's real production inputs and outputs to compare against, and those disappear on January 14.

Why swapping the model ID isn't enough

GPT-4o and GPT-4.1 answer immediately. GPT-6 Luna is a reasoning model. Its model page says reasoning.effort supports none, low, medium (default), high, xhigh and max. If you change model="gpt-4.1" to model="gpt-6-luna" and leave the rest alone, you get medium reasoning on every request. That changes three things at once.

1. Latency and cost per request go up from the default

Reasoning tokens are generated before the visible answer. They add time-to-first-token and they are billed (OpenAI has historically charged reasoning tokens at the output rate). Luna's list prices are low, but a request that reasons at medium effort can produce several times as many output tokens as the same request on GPT-4.1. Datanorth makes the same point: list prices don't show cost per task, because reasoning settings change token usage.

2. Tool calling depends on the API you use

This is the most likely source of breakage. Luna's model page says: "Chat Completions supports function calling only with reasoning_effort set to none." If your agent runs on Chat Completions with tools, either pin reasoning_effort="none" or move that path to the Responses API, which supports reasoning combined with tool calls.

3. Sampling parameters are rejected once reasoning is on

OpenAI's latest-model guide says that when reasoning effort is not none, you should remove temperature, top_p and top_logprobs, plus logprobs on Chat Completions (or message.output_text.logprobs from include on Responses). If your pipeline relies on logprobs for confidence scoring or classification thresholds, that logic only keeps working at reasoning_effort="none".

Prompt behavior also changes. Luna has a newer knowledge cutoff (May 18, 2026), a different instruction-following style, and different defaults for verbosity and formatting. OpenAI's prompting guidance targets GPT-6 Astra and tells you to evaluate it against your own model and workload. No guide can predict how your specific prompts will behave.

GPT-6 Luna vs GPT-4o and GPT-4.1: specs and pricing

Standard per-1M-token prices from OpenAI's pricing page, as of October 2026 (short context, at or below 272K input tokens):

Pricing details to model before you switch:

• Long prompts cost more. Prompts over 272K input tokens are billed at 2x input and cache rates and 1.5x output for the whole request. On Luna that's $0.20 input, $0.02 cached and $0.75 output.
• Cache writes are billed. Luna's pricing is $0.125 per 1M tokens for 30-minute cache writes and $0.25 per 1M for 12-hour writes, per the pricing page. Both are above its $0.10 base input rate. The latest-model guide also tells you to review the prompt caching changes, including cache boundaries and the new prompt_cache_options.ttl setting.
• Batch and Flex are 50% of Standard. Fast mode (formerly priority processing) costs more and the multiplier varies by model; for Luna the pricing page lists $0.20 input / $1.00 output, which is 2x Standard.
• EU data residency through regional processing endpoints adds 10% for models released on or after March 5, 2026, which includes Luna.

Luna's other specs from its model page: 1,050,000-token context window (roughly 922,000 input tokens if you reserve the full output budget), 128,000 max output tokens, text and image input, and text output. It runs on the Chat Completions, Responses and Batch endpoints, with streaming, structured outputs and function calling (on Chat Completions, function calling only at reasoning_effort none). Built-in tools such as web search and file search are listed for the Responses API, and cached-input pricing applies for prompt caching. If Luna can't match GPT-4.1 quality on a hard workload even with higher reasoning effort, the next step up is GPT-6.1 Sol, which costs about 20x as much per token.

Cost modeling: a worked example

Take a workload that sends 2,000M (2 billion) input tokens and receives 400M output tokens per month, with no caching, at standard list prices.

Three takeaways:

• Coming from GPT-4o or GPT-4.1, Luna is much cheaper at any reasonable reasoning level: $800 vs $7,200 even in the reasoning-heavy scenario.
• Coming from GPT-4o mini, Luna is clearly cheaper only at effort none; at low or above it depends on how many reasoning tokens your workload generates. In the hypothetical case where reasoning triples output tokens (400M to 1,200M), the bill grows from $540 to $800. The 3x multiplier is an illustration, not a measurement, so measure your own reasoning-token counts on the eval set before you sign off on a budget.
• Fine-tuned models were priced at a premium: fine-tuned gpt-4.1-2025-04-14 inference lists at $3.00 input / $12.00 output. At 500M input and 100M output per month, that's 500 × $3.00 + 100 × $12.00 = $2,700. Swapping it for Luna with a prompt three times longer (1,500M input) costs 1,500 × $0.10 + 100 × $0.50 = $200 before caching. That leaves plenty of budget for longer prompts or retrieval.

For a broader view of where Luna sits among budget models, see our comparison of the cheapest fast LLM APIs, and our guide to how prompt caching reduces AI cost.

Code: the minimal safe migration

To keep GPT-4o-like behavior while you run evals, start with reasoning off. On Chat Completions, this is also the only setting that keeps function calling working:

from openai import OpenAI

client = OpenAI()

resp = client.chat.completions.create(
    model="gpt-6-luna",
    reasoning_effort="none",  # closest to GPT-4o / GPT-4.1; required for tools on Chat Completions
    messages=[
        {"role": "system", "content": "You are a support triage assistant."},
        {"role": "user", "content": "My invoice shows a duplicate charge."},
    ],
)
print(resp.choices[0].message.content)

Where evals show that reasoning helps and you also need tools, move that path to the Responses API:

resp = client.responses.create(
    model="gpt-6-luna",
    reasoning={"effort": "low"},
    input="Classify this ticket and extract the order ID: 'Order 48213 arrived damaged.'",
    text={
        "format": {
            "type": "json_schema",
            "name": "ticket",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "category": {"type": "string", "enum": ["billing", "shipping", "technical", "other"]},
                    "order_id": {"type": ["string", "null"]},
                },
                "required": ["category", "order_id"],
                "additionalProperties": False,
            },
        }
    },
)
print(resp.output_text)

Keep the model name and reasoning effort in configuration, not in code, so rollback is a config change:

import os

MODEL = os.environ.get("LLM_MODEL", "gpt-6-luna")
EFFORT = os.environ.get("LLM_REASONING_EFFORT", "none")

Migration checklist

1. Inventory every call site. Search code, config, infrastructure-as-code and third-party tools for gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini, the dated snapshot IDs, and any ft:gpt-4o / ft:gpt-4.1 model names. OpenAI's deprecations page says the List models endpoint returns an optional shutdown_date field (a YYYY-MM-DD string), which helps you build an automated check.
2. Capture an eval set now. Log 200–1,000 real production requests per use case together with the current model's outputs. For fine-tunes this is urgent, because the reference model disappears on January 14. OpenAI's own Evals platform goes read-only for existing evals on October 31, 2026 and its dashboard and API shut down on November 30, 2026, so export any existing evals now and use a tool you control (OpenAI points to Promptfoo as a migration path).
3. Baseline at reasoning_effort="none". Compare quality, latency and output-token counts against GPT-4o/4.1 on the eval set. Many extraction, classification and rewriting workloads stop here.
4. Raise effort only where the evals improve. Test low and medium on the use cases that failed. Record the quality gain against the extra reasoning tokens and latency.
5. Re-verify structured outputs and tools. Confirm JSON schema compliance, tool-call argument accuracy, and parallel tool behavior. Move any reasoning-plus-tools path from Chat Completions to Responses.
6. Strip incompatible parameters. Remove temperature, top_p, top_logprobs and logprobs wherever effort is above none. Replace logprob-based confidence logic if needed.
7. Model costs at $0.10 / $0.50. Use measured token counts, not list-price guesses. Include cache writes ($0.125–$0.25/1M depending on TTL), the 272K long-context multiplier, and Batch (50% off) for offline jobs.
8. Replace fine-tunes before January 6. If you might want one last training run (for example, to distill into another provider's format or to compare), do it before job creation closes on January 6, 2027.
9. Roll out with a canary and a rollback. Shadow traffic first, then ramp from 5% to 25% to 100% behind a flag. Keep the old model as the rollback target, and remember it only works until January 14. After that, your rollback is a different Luna setting or a different model, so test that fallback too.
10. Finish with buffer. Aim to be on Luna in production by mid-December so holiday change freezes don't collide with the shutdown.

If you need more time than OpenAI's schedule allows, OpenAI's deprecations page says some developers may be able to provision dedicated capacity for continued access after a model's shutdown date through its sales team. Treat that as a commercial negotiation, not a plan.

The full OpenAI deprecation calendar (late 2026 to early 2027)

Many teams that run GPT-4o also run older audio, image or o-series models. These are the upcoming and recent shutdowns from OpenAI's deprecations page:

If you're still cleaning up after the October 23 cutoff, our guide to replacing GPT-3.5 Turbo covers that migration.

FAQ

When exactly does GPT-4o stop working in the OpenAI API?

The gpt-4o-2024-08-06 and gpt-4o-2024-11-20 snapshots shut down on January 14, 2027. The older gpt-4o-2024-05-13 snapshot already shut down on October 23, 2026. GPT-4o mini (gpt-4o-mini-2024-07-18) shares the January 14 date.

What is the official GPT-4o replacement?

OpenAI recommends gpt-6-luna for GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini. It costs $0.10 input, $0.01 cached input and $0.50 output per 1M tokens as of October 2026. For harder workloads where Luna falls short, GPT-6.1 Sol is the next tier up.

Will my fine-tuned GPT-4o or GPT-4.1 model keep working?

No. Fine-tuned versions follow the base model's shutdown schedule, so they stop on January 14, 2027. New fine-tuning jobs stop on January 6, 2027, and GPT-6 Luna can't be fine-tuned. Plan to replace fine-tunes with prompting, retrieval, selective reasoning, or another provider.

Is GPT-6 Luna a drop-in replacement?

Not by default. It reasons at medium effort unless you set reasoning_effort="none", Chat Completions only supports function calling at none, and sampling parameters like temperature and logprobs must be removed once reasoning is on. Start at none, run evals, and raise effort only where it measurably helps.

Does Azure OpenAI follow the same date?

Not currently. As of its September 23, 2026 update, Microsoft's retirement schedule lists April 14, 2027 for the same GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini versions, with later dates for fine-tuned deployments. Microsoft can revise these dates, so check the schedule directly.

Why is the notice only three months?

OpenAI hasn't publicly explained it. The New Stack notes that its deprecation policy promises at least six months' notice for generally available models, with exceptions for safety or compliance reasons.

Sources

• OpenAI API: Deprecations
• OpenAI API: GPT-6 Luna model page
• OpenAI API: Pricing
• OpenAI API: Latest model guide
• Microsoft Foundry: Model retirement schedule
• Microsoft Foundry: Models lifecycle and support policy
• The New Stack: OpenAI promised developers six months' notice. GPT-4o users got three.
• Datanorth: GPT-4o and GPT-4.1 leave OpenAI's API on 14 January 2027

For a deeper look at the replacement model, read our GPT-6 Luna complete guide. If your team needs extra hands to get evals, fine-tune replacements and rollout done before January 14, Codersera can help you extend your engineering team with vetted remote developers for a focused migration sprint.