GPT-4o and GPT-4.1 to Exit OpenAI API on January 14, 2027 — Developers Have Only 92 Days

OpenAI quietly added a notice to its deprecation page on October 14, 2026: developers using GPT-4o, GPT-4o mini, GPT-4.1, and GPT-4.1 mini were told the models would be removed from the API on January 14, 2027. From notice to shutdown, that's just 92 days.

There was no launch event, no email blast — just a table. If you built a classifier, an information extractor, or a customer ticket router on one of these smaller models over the past two years, that one call nobody has touched since will simply stop working after January 14.

Which Models Are on the List

According to OpenAI's official deprecation page, the four models going offline in this round and their snapshots are as follows:

Model	Snapshot ID	Replacement
GPT-4o	gpt-4o-2024-08-06, gpt-4o-2024-11-20	gpt-6-luna
GPT-4o mini	gpt-4o-mini-2024-07-18	gpt-6-luna
GPT-4.1	gpt-4.1-2025-04-14	gpt-6-luna
GPT-4.1 mini	gpt-4.1-mini-2025-04-14	gpt-6-luna

One line in the notice is worth noting: fine-tuned versions of these models follow the same shutdown schedule as the base models. In other words, a fine-tuned 4o mini will vanish entirely on the same day.

The table lists dated snapshots, not the bare gpt-4o alias. The GPT-4o model page lists gpt-4o-2024-08-06 as the default snapshot, and that snapshot is on the list. Don't assume the alias will live longer — check the exact ID you're actually calling.

Also, gpt-4o-2024-05-13 and gpt-4.1-nano were already in the deprecation pipeline before this notice and will be shut down on October 23, 2026. If you pinned those two versions, your deadline isn't 92 days — it's 9 days.

GPT-4o's audio and realtime models are not on this list; they have separate dates starting January 20, 2027.

The Gap Between a Three-Month Notice and a Six-Month Policy

OpenAI's deprecation page includes a note about notice periods: for generally available models, it promises "at least 6 months"; for specialized variants, "at least 3 months"; and for preview models, they "may be retired with shorter notice, such as 2 weeks."

October 14 to January 14 is exactly three months. The notice doesn't say which category these snapshots fall into, doesn't give a reason for the shortened timeline, and doesn't attach a migration guide.

Compare that with the entry just below: on October 1, OpenAI set a shutdown date of April 1, 2027 for gpt-5.1 and gpt-5.3-codex — a full six months, double this notice period.

If you use these models through Azure, the dates don't follow OpenAI's timeline. Microsoft's model retirement page lists these five snapshots as retiring on April 14, 2027, with fine-tuned deployments lasting longer: gpt-4o and gpt-4o-mini until October 1, 2027, and gpt-4.1 and gpt-4.1-mini until October 14, 2027. However, that page was last updated in late September, before OpenAI's notice, so it's worth keeping an eye on for changes.

What Migrating to gpt-6-luna Involves

Looking at price per million tokens, Luna is cheaper than every model it replaces:

Model	Input Price	Output Price
gpt-4o	$2.50	$10.00
gpt-4.1	$2.00	$8.00
gpt-4.1-mini	$0.40	$1.60
gpt-4o-mini	$0.15	$0.60
gpt-6-luna	$0.10	$0.50

But cheaper per token doesn't mean cheaper per task. The Luna model page lists three key differences that will change how existing calls behave:

Reasoning is on by default. Luna reasons at medium effort by default unless you explicitly set reasoning.effort. Effort can range from none to max. A 4o mini classifier answers instantly, while Luna thinks first under default settings.

Tool calling favors the Responses API. On Chat Completions, function calling is only available when reasoning effort is none. To use built-in tools, you need to switch to the Responses API.

No fine-tuning support. Luna doesn't support fine-tuning. If your production model is a fine-tuned 4o mini, there's no equivalent fine-tuned Luna to migrate to. OpenAI has restricted new fine-tuning jobs since May 2026, and existing customers will lose the ability to create fine-tuning jobs on January 6, 2027.

Also, long prompts cost more. When input exceeds 272K tokens, Luna charges 2x for input across the entire request and 1.5x for output.

For a fast, cheap call originally sent to 4o mini, the closest replacement starting point is Luna with reasoning disabled:

import OpenAI from "openai";

const client = new OpenAI();

const res = await client.responses.create({
  model: "gpt-6-luna",
  reasoning: { effort: "none" },
  input: "Label this ticket: refund not received",
});

console.log(res.output_text);

But before switching, be sure to run a comparison against your evaluation set. OpenAI's notice makes no promises about quality after the swap, and 92 days is exactly the window to build that evaluation set.

reasoning.effort is a reasoning budget control parameter OpenAI introduced on its new generation of reasoning models, replacing the earlier o-series approach where thinking depth could only be indirectly influenced through system prompts. It exposes the model's "amount of thinking" as an explicit gradient from none to max: none means skipping the internal reasoning chain and generating an answer directly; medium is the default for most models; and max allows the model to unfold as long a chain of thought as possible before answering. This parameter directly affects latency, output token count, and billing — tokens produced during reasoning are also billed as output. For tasks like classification, extraction, and routing where "input is clear and the answer is unique," setting effort to none often strikes a better balance between quality and cost than older models; for tasks requiring multi-step derivation, raising effort typically brings significant quality gains. The most common pitfall during migration is treating the new model as an equivalent replacement for the old one, only to find that the default medium adds seconds of latency and multiples of output cost to a simple call out of nowhere.

The Responses API is a new interface OpenAI introduced alongside Chat Completions, and the core difference between the two lies in state management. Chat Completions is stateless: every request must resend the full conversation history, and the server retains nothing. The Responses API allows the server to save conversation state, so the client only needs to pass previous_response_id to continue the context, while built-in tools (web search, file retrieval, code execution, etc.) are attached directly to the request as first-class citizens. This design turns tool-calling orchestration from a multi-round back-and-forth of "client parses function call, executes, sends result back" into a loop the server can complete autonomously. The cost is that interface semantics, return structures, and billing rules all differ from Chat Completions, and existing parsing code, retry logic, and token accounting almost all need to be rewritten. For applications heavily reliant on function calling, this isn't a migration you can complete by just changing a URL.

Find Every Call Before January Arrives

Start with your own code. git grep only searches tracked files, which usually skips node_modules and build artifacts:

git grep -nE "gpt-4(o|\.1)"

This pattern will also match audio, realtime, TTS, and transcription variants, as well as the two snapshots from the April notice with different dates. So read the hits rather than simply counting them. Then check the places grep can't see: environment variables, config services, feature flags, and database rows that store model names.

Next, ask the API. OpenAI says the List models endpoint now carries an optional shutdown_date field. Using jq, you can print all models in your account with announced shutdown dates, sorted from earliest to latest:

curl -s https://api.openai.com/v1/models \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  | jq -r '.data[]
      | select(.shutdown_date != null)
      | "\(.shutdown_date)  \(.id)"' \
  | sort

Environment variables, config services, feature flags, and database rows are blind spots for code search, yet they're often where model IDs actually take effect. A typical case: the code says process.env.OPENAI_MODEL, but the real value lives in a Kubernetes ConfigMap, AWS Parameter Store, LaunchDarkly flag, or a column in a tenants table — or different tenants of the same application are even bound to different snapshots. Such external configuration also drifts over time — someone temporarily switches to gpt-4o-mini for a canary release and never changes it back. So the investigation must go both ways: bottom-up using grep to find code references, and top-down from production traffic to trace the actual model IDs being called. A reliable approach for the latter is to check the model field in API response headers or usage logs, using real traffic rather than static configuration to confirm "what is actually being called right now." Only when both sides match can you claim a complete inventory.

Make the Build Fail Before the API Does

The same field also appears on the Retrieve a model endpoint, and a few lines of shell can detect in your pipeline whether the model your deployment uses has a shutdown date:

#!/usr/bin/env bash

GitHub Actions workflow commands are a set of special strings in the form `::name parameter::value`. A script prints these strings to standard output, and the runner intercepts and converts them into annotations, groups, or environment variable settings in the UI. `::error::` generates a red error annotation and displays it directly on the corresponding step and PR file diff; `::warning::` is a yellow warning; and `::notice::` is a blue notice. These annotations don't change a step's exit code, so they're often paired with `exit 1`: the annotation is responsible for showing information to people, and the non-zero exit code is responsible for actually stopping the pipeline. Note that workflow commands must appear at the start of a line to be recognized, and newlines, percent signs, and carriage returns in the message need to be escaped. Compared to simply printing a line of log, the value of annotations is that they can be searched and collapsed on the PR page and in the Actions summary, so information like "which model is about to shut down" doesn't get buried in thousands of lines of build output.
# Fail CI when the model we call has a shutdown date.
set -euo pipefail
model="${OPENAI_MODEL:?set OPENAI_MODEL}"
url="https://api.openai.com/v1/models/$model"

shutdown=$(curl -sSf "$url" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  | jq -r '.shutdown_date // empty')

if [ -n "$shutdown" ]; then
  echo "::error::$model shuts down on $shutdown"
  exit 1
fi
echo "$model: no shutdown date announced"

::error:: is a GitHub Actions workflow command prefix that displays annotations on the run log. Once the model is removed, curl -f will fail on the error response, and the script will exit with a non-zero status as well. Set OPENAI_MODEL to a dated snapshot rather than an alias.

Failing on any announced date is intentionally strict: teams learn about the next deprecation from a red build rather than from an archived email. If that's too noisy, compare the date against a window and only fail within that window.

Treat model IDs like runtime versions or database engines — they're a dependency whose lifecycle you don't control. Put it in one consistent place in your configuration, and maintain an evaluation set so you can judge within an afternoon whether a replacement model holds up.

What the 92-Day Countdown Really Means

This deprecation event reflects a trend: model lifecycles are getting shorter and shorter, while infrastructure dependency management hasn't caught up. The 4o snapshot released in 2024 faces shutdown just over two years later, and its replacement Luna differs fundamentally in default behavior, tool-calling approach, and fine-tuning support.

For teams relying on the OpenAI API, 92 days isn't a time to panic — it's a time to establish a model lifecycle management process. Bring model IDs into configuration management, build evaluation sets as a safety net for migration, and let CI discover the next deprecation notice for you when it arrives. Models will retire, but your product doesn't have to retire with them.

One-line Summary

OpenAI is shutting down four models including GPT-4o with only 92 days' notice, and developers need to quickly audit their calls and address migration risks.

Paragraph Summary

On October 14, 2026, OpenAI quietly notified users via its deprecation page that GPT-4o, GPT-4o mini, GPT-4.1, and GPT-4.1 mini plus their fine-tuned versions will be removed from the API on January 14, 2027, giving only a 92-day migration window — well below its promised 6-month notice period for generally available models. The replacement model gpt-6-luna costs less per token, but enables reasoning by default, has limited tool calling on Chat Completions, and doesn't support fine-tuning at all, so existing fine-tuned models can't be migrated smoothly. Azure customers have later retirement dates, with the GPT-4o series until April 14, 2027, and fine-tuned deployments retained as late as October 2027. The article recommends using git grep to search code, checking environment variables and config services, leveraging the shutdown_date field on the List models and Retrieve a model endpoints, and wiring deprecation checks into the CI pipeline so builds automatically fail and alert when the next notice arrives — thereby building model lifecycle management capabilities.