## Azure OpenAI model retirement: every date, auto-upgrades and how to migrate

URL: https://www.evalshift.dev/blog/azure-openai-model-retirement
Published: 2026-11-24
Tag: migration
Summary: Azure OpenAI retires gpt-4o 2024-05-13 on January 14, 2027 and GPT-4o mini and GPT-4.1 on April 14. Every date, what auto-upgrades, and how to migrate.

Takeaways:
- Azure OpenAI retires gpt-4o version 2024-05-13 on January 14, 2027. From that date its Global Standard and Data Zone Standard deployments are upgraded, region by region, to gpt-5.1 version 2025-11-13 under the same deployment name, and its Provisioned deployments stop serving.
- Azure retires gpt-4o versions 2024-08-06 and 2024-11-20, gpt-4o-mini, gpt-4.1, gpt-4.1-mini and gpt-4.1-nano on April 14, 2027, three months after OpenAI's API shuts down most of them on January 14, 2027. Microsoft lists gpt-5.1 as the replacement for gpt-4o and no replacement yet for the others.
- On Azure OpenAI, a retired model version returns 410 Gone. Standard deployments are upgraded to the listed replacement where it's offered for that deployment type and region, unless their versionUpgradeOption is NoAutoUpgrade, Provisioned deployments are never upgraded automatically, and Microsoft says retirement dates can't be extended.
- gpt-5.1, Azure's replacement for gpt-4o, is a reasoning model with reasoning_effort none by default on Azure. Azure lists temperature, top_p and max_tokens among the parameters its reasoning models don't support, and gpt-5.1 itself retires on Azure on July 13, 2027.
- Fine-tuned gpt-4o and gpt-4o-mini deployments on Azure OpenAI keep serving until October 1, 2027, and fine-tuned gpt-4.1 and gpt-4.1-mini until October 14, 2027, months after their base models retire. On OpenAI's API they shut down with the base on January 14, 2027.

The next big Azure OpenAI model retirement is `gpt-4o` version 2024-05-13 on January 14, 2027. On
that day, Global Standard and Data Zone Standard deployments of it are upgraded to `gpt-5.1`
version 2025-11-13 automatically, and Provisioned deployments stop serving. Three months later, on
April 14, 2027, Azure retires `gpt-4o` versions 2024-08-06 and 2024-11-20, `gpt-4o-mini`,
`gpt-4.1`, `gpt-4.1-mini` and `gpt-4.1-nano`. Every o-series model still on Azure's schedule (`o1`,
`o1-pro`, `o3`, `o3-pro`, `o3-mini`, `o4-mini` and `o3-deep-research`) was scheduled to retire on
November 19, 2026.

Four things about Azure's retirements catch teams that know OpenAI's:

- **The dates are Azure's own.** `gpt-4o` 2024-08-06 shuts down on OpenAI's API on January 14,
  2027 and on Azure on April 14, 2027. The o-series is mixed: `o3` and `o3-pro` were scheduled to
  retire on Azure on November 19, 2026, three weeks before OpenAI's December 11, while `o1`,
  `o3-mini` and `o4-mini` shut down on OpenAI's API first, on October 23.
- **A retirement can swap the model under you.** Standard deployments are upgraded at retirement
  by default, under the same deployment name. A Global or Data Zone Standard deployment of `gpt-4o`
  2024-05-13 is upgraded in place, region by region, from January 14, and starts answering with a
  reasoning model your code never called.
- **Deprecated means closed to new subscriptions.** Once a model is Deprecated, only an Azure
  subscription that has already deployed that exact version can create new deployments of it. A
  new subscription in the same tenant can't.
- **The replacement is named late, and the date can't move.** Microsoft picks the official
  replacement about 90 to 120 days before retirement, and its FAQ says retirement dates aren't
  extendable.

The rest of this post is every upcoming Azure OpenAI date for text and reasoning models, what
happens to each deployment type on the day, what changes when `gpt-4o` becomes `gpt-5.1`, the
fine-tuned model dates, and a six-step migration. The facts come from Microsoft's
[model retirement schedule](https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirement-schedule)
(last updated November 18, 2026), its
[lifecycle and support policy](https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirements),
its [model versions](https://learn.microsoft.com/en-us/azure/foundry/foundry-models/concepts/model-versions)
and [reasoning models](https://learn.microsoft.com/en-us/azure/foundry/openai/how-to/reasoning)
pages, all read on November 19, 2026. Azure OpenAI is now documented under Microsoft Foundry, and
Microsoft revises the schedule often, so check it again before you act on a date.

## Azure OpenAI retirement dates, November 2026 to July 2027

These are the chat, reasoning and Codex models. Each row is one model version, which is how Azure
retires models: a deployment pins a version, and the version is what retires.

| Retirement date | Model and version | Stage today | Listed replacement |
| --- | --- | --- | --- |
| November 17, 2026 (past) | `codex-mini` 2025-05-16; `gpt-chat-latest` 2026-05-05 and 2026-06-24 | Retired | None listed |
| November 19, 2026 (past) | `o1` 2024-12-17, `o1-pro` 2025-03-19, `o3` 2025-04-16, `o3-pro` 2025-06-10, `o3-deep-research` 2025-06-26 | Retired | `gpt-5.6-sol` |
| November 19, 2026 (past) | `o3-mini` 2025-01-31, `o4-mini` 2025-04-16 | Retired | `gpt-5.6-terra` |
| December 8, 2026 | `gpt-chat-latest` 2026-05-28 | Preview | None listed |
| January 12, 2027 | `gpt-chat-latest` 2026-08-06 | Preview | None listed |
| January 14, 2027 | `gpt-4o` 2024-05-13 | Deprecated | `gpt-5.1` 2025-11-13, applied automatically on Global Standard and Data Zone Standard |
| February 2, 2027 | `gpt-chat-latest` 2026-10-07 | Preview | None listed |
| February 9, 2027 | `gpt-5` 2025-08-07, `gpt-5-nano` 2025-08-07 | GA | None listed |
| March 17, 2027 | `gpt-5-codex` 2025-09-15 | GA | None listed |
| April 7, 2027 | `gpt-5-pro` 2025-10-06 | GA | None listed |
| April 14, 2027 | `gpt-4o` 2024-08-06 and 2024-11-20 | Deprecated; Legacy | `gpt-5.1` |
| April 14, 2027 | `gpt-4o-mini` 2024-07-18, `gpt-4.1`, `gpt-4.1-mini` and `gpt-4.1-nano` 2025-04-14 | Deprecated | None listed yet |
| May 15, 2027 | `gpt-5.1-codex` and `gpt-5.1-codex-mini` 2025-11-13 | GA | None listed |
| May 18, 2027 | `gpt-5.1-codex-max` 2025-12-04 | GA | None listed |
| June 8, 2027 | `gpt-5.2` 2025-12-11 | GA | None listed |
| July 13, 2027 | `gpt-5-mini` 2025-08-07, `gpt-5.1` 2025-11-13, `gpt-5.2-codex` 2026-01-14 | GA | None listed |

"None listed yet" on the April 14 row is expected. Microsoft names the official replacement about
90 to 120 days before a retirement, so the `gpt-4o-mini` and GPT-4.1 targets should appear
between mid-December and mid-January. Don't wait for it: the policy says the listed replacement
"doesn't limit your manual migration choices."

The audio and speech models have their own dates. `whisper`, `tts` and `tts-hd` retire on
December 15, 2026, the March 2025 `gpt-4o-mini-transcribe` and `gpt-4o-mini-tts` versions on
January 20, 2027, `gpt-4o-transcribe` 2025-03-20 on February 26, 2027, and `gpt-audio` and
`gpt-realtime` 2025-08-28 on March 2, 2027. The embedding models, `text-embedding-3-large`,
`text-embedding-3-small` and `text-embedding-ada-002`, run until February 9, 2028.

For the same dates side by side with OpenAI, Anthropic, Google and AWS Bedrock, see the
[LLM model deprecation schedule](/blog/llm-model-deprecation-schedule).

## What happens to a deployment on the retirement date

A retired model version returns `410 Gone` on every inference request. Whether your deployment is
still on that version when the date arrives depends on two things: its deployment type and its
version upgrade policy.

| Deployment | What happens at retirement |
| --- | --- |
| Global Standard, Data Zone Standard or Standard, upgrade policy `OnceCurrentVersionExpired` (the default) | Upgraded under the same deployment name, on a rolling region-by-region schedule: to Microsoft's listed replacement where it's offered for that deployment type and region, otherwise to the current default version |
| Same, upgrade policy `OnceNewDefaultVersionAvailable` | Already moves to each new default version within two weeks of it becoming the default |
| Same, upgrade policy `NoAutoUpgrade` | Stops working. Requests fail until you point the deployment at a supported version |
| Global, Data Zone or Regional Provisioned | Never upgraded automatically. Stops serving unless you migrated it first |
| Global Batch | Not covered by the automatic upgrade. Deploy the new model and resubmit jobs to it |
| Preview models, any type | Force-upgraded to a newer version or retired, with at least 30 days' notice. There's no staying on a retiring preview |

Two details in the upgrade path matter. First, a deployment that never had its policy set shows
no `versionUpgradeOption` at all, and Microsoft documents a missing value as equivalent to
`OnceCurrentVersionExpired`. So unless someone chose otherwise, your Standard deployments will be
upgraded. Second, the upgrade doesn't wait for the replacement to exist in your region. Microsoft's
model versions page says that if the new version isn't available in a region yet, it deploys it
there as part of the upgrade.

`gpt-4o` 2024-05-13 has a third wrinkle: its Regional Standard deployments already retired on March
31, 2026. The January 14 date covers Global Standard, Data Zone Standard, the three Provisioned
types and Global Batch.

## What changes when gpt-4o becomes gpt-5.1 on January 14

Microsoft's listed replacement for every `gpt-4o` version is `gpt-5.1`, pinned to version
2025-11-13 for the 2024-05-13 retirement. For that version, Global Standard and Data Zone Standard deployments switch to it automatically
on January 14. The deployment keeps its name, your code keeps calling the same endpoint, and the
answers now come from a different model. Here is what differs:

- **`gpt-5.1` is a reasoning model.** On Azure its `reasoning_effort` defaults to `none`, so after
  the upgrade it answers without reasoning unless you send a higher effort. Microsoft's reasoning
  page calls this out as a migration note for code coming from older reasoning models.
- **Some request parameters are listed as unsupported.** Azure's reasoning models page says
  reasoning models other than GPT-6 Astra don't support `temperature`, `top_p`,
  `presence_penalty`, `frequency_penalty`, `logprobs`, `top_logprobs`, `logit_bias` or
  `max_tokens`, and that Chat Completions needs `max_completion_tokens` instead of `max_tokens`.
  The page makes no exception for `none`, so test the exact request your code sends: a `gpt-4o`
  request with `temperature` and `max_tokens` is the most common shape there is.
- **Azure's feature table lists streaming as unsupported for `gpt-5.1` 2025-11-13.** OpenAI's own
  model page lists streaming as supported, so this may be a gap in Azure's table, but test your
  streaming requests against a `gpt-5.1` deployment before January 14 rather than find out on the
  day.
- **Reasoning tokens are billed as output.** At `none` there are few or none. If you raise the
  effort to recover quality, the cost per request rises with it, and `max_completion_tokens` caps
  reasoning and visible output together.
- **The upgrade buys six months.** `gpt-5.1` 2025-11-13 itself retires on Azure on July 13, 2027,
  and OpenAI's API already lists `gpt-5.1` as deprecated, with an April 1, 2027 shutdown. A
  deployment that rides the January 14 upgrade will face another migration by July.

That last point is the reason not to treat the automatic upgrade as the migration. It keeps the
endpoint up. It doesn't test the new model on your traffic, and it lands you on a version with its
own date.

The April 14 retirement of `gpt-4o` 2024-08-06 and 2024-11-20 also lists `gpt-5.1` as the
replacement. For `gpt-4o-mini` and the GPT-4.1 models, no replacement is listed yet, so nobody can
tell you today which model a Standard deployment of them will be upgraded to.

## Azure OpenAI and OpenAI retire the same models on different dates

Azure and OpenAI each run their own schedule for the same model families:

| Model and version | OpenAI API | Azure OpenAI |
| --- | --- | --- |
| `gpt-4o` 2024-05-13 | Shut down October 23, 2026 | January 14, 2027 |
| `gpt-4o` 2024-08-06 and 2024-11-20, `gpt-4o-mini`, `gpt-4.1`, `gpt-4.1-mini` | January 14, 2027 | April 14, 2027 |
| `gpt-4.1-nano` | Shut down October 23, 2026 | April 14, 2027 |
| `o3`, `o3-pro` | December 11, 2026 | November 19, 2026 |
| `o1`, `o3-mini`, `o4-mini` | Shut down October 23, 2026 | November 19, 2026 |
| `gpt-5`, `gpt-5-nano` | December 11, 2026 | February 9, 2027 |
| `gpt-5-mini` | December 11, 2026 | July 13, 2027 |
| `gpt-5.1` | April 1, 2027 | July 13, 2027 |

Two consequences follow. A team on both platforms can't plan from one page, because a fallback
from Azure to OpenAI (or the reverse) can point at a model that is already gone on the other
side. And the replacements differ: OpenAI's listed replacement for `gpt-4o` and `gpt-4.1` is
`gpt-6-luna`, while Azure's is `gpt-5.1`. The
[GPT-4o and GPT-4.1 shutdown guide](/blog/gpt-4o-gpt-4-1-deprecation) covers OpenAI's side.

## Fine-tuned models outlive their base model on Azure

On Azure, a fine-tuned model retires in two phases: training, when you can no longer create new
fine-tunes of that base, and deployment, when existing fine-tuned deployments stop serving. The
deployment dates run months past the base model's retirement:

| Base model and version | Base model retires | Training retires (existing customers) | Fine-tuned deployments retire |
| --- | --- | --- | --- |
| `gpt-4o` 2024-08-06 | April 14, 2027 | No earlier than April 1, 2027 | October 1, 2027 |
| `gpt-4o-mini` 2024-07-18 | April 14, 2027 | No earlier than April 1, 2027 | October 1, 2027 |
| `gpt-4.1` 2025-04-14 | April 14, 2027 | No earlier than April 14, 2027 | October 14, 2027 |
| `gpt-4.1-mini` 2025-04-14 | April 14, 2027 | No earlier than April 14, 2027 | October 14, 2027 |
| `gpt-4.1-nano` 2025-04-14 | April 14, 2027 | No earlier than April 14, 2027 | April 13, 2028 |
| `o4-mini` 2025-04-16 | November 19, 2026 | No earlier than May 19, 2027 | November 19, 2027 |

For customers who haven't fine-tuned that base before, training retires with the base model. The
`o4-mini` row is the one to double-check: the retirement schedule says November 19, 2027, but the
lifecycle policy page, last updated July 24, 2026, still says October 16, 2027 for deployments and
April 16, 2027 rather than May 19 for training.

This is the biggest difference from OpenAI's API, where fine-tunes of `gpt-4o` and `gpt-4.1` stop
serving on January 14, 2027 together with their base. If you run fine-tunes on both platforms, the
Azure copy is the one you can still record a baseline from in mid-2027.

## How Azure's model lifecycle works

Microsoft's lifecycle policy gives every model one of five stages:

| Stage | New deployments | Existing deployments |
| --- | --- | --- |
| Preview | Yes | Work, but weights and API can change, and the model can be force-upgraded or retired with 30 days' notice |
| Generally available (GA) | Yes | Work |
| Legacy (optional) | Yes, until deprecation | Work |
| Deprecated | Only subscriptions that have deployed this exact model version | Work |
| Retired | No | Every request returns `410 Gone` |

A GA model's retirement date is set when it launches, normally 18 months out, and Microsoft says
there is no separate announcement: the date is set at launch and readable from the Models API.
Not every model gets 18 months (`gpt-6.1-terra` 2026-10-26 is listed to retire after 12), so read
the date rather than assume it. The standard pattern is deprecation at 12 months, the replacement available on Global Standard about
90 days before retirement and on Provisioned about 30 days before, and retirement at 18 months.
GA models from Anthropic, DeepSeek, Fireworks and Mistral AI on Foundry follow a 12-month
lifecycle instead.

The Deprecated stage is where teams get caught. "Existing customer" is decided per Azure
subscription: whether that subscription has ever deployed that model version. A new subscription
for a new environment or region, even under the same tenant, can't deploy a Deprecated model. That
is why `gpt-4o` 2024-11-20 matters: it is Legacy, not Deprecated, so it is the one `gpt-4o`
version a new subscription can deploy today, until Microsoft moves it to Deprecated. Microsoft
can also limit new customers in specific regions.

Microsoft notifies subscription owners with active deployments by email at least 60 days before a
GA retirement and at least 30 days before a preview one, and posts Azure Service Health advisories.
Service Health has no "Microsoft Foundry" service: filter on Azure OpenAI Service. Security or
compliance problems can trigger an emergency retirement with shorter notice, and the policy FAQ
says retirement dates can't be extended. Azure Government clouds usually run one version of a
model at a time, with a 30-day overlap when a new one arrives.

## Step 1: Inventory every deployment and its upgrade policy

The retirement schedule lists models, but what retires for you is deployments. List them per
Azure OpenAI resource with the Azure CLI:

```bash
az cognitiveservices account deployment list \
  --resource-group my-rg --name my-openai-resource \
  --query "[].{deployment:name, model:properties.model.name, version:properties.model.version, sku:sku.name, upgrade:properties.versionUpgradeOption}" \
  --output table
```

An empty `upgrade` column means the policy was never set, which behaves as
`OnceCurrentVersionExpired`. Then check each model's lifecycle from the Models API, which is
subscription-scoped and per region:

```bash
az rest --method get \
  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/eastus2/models?api-version=2024-10-01" \
  --query "value[?model.name=='gpt-4o'].{version:model.version, status:model.lifecycleStatus, retires:model.deprecation.inference}" \
  --output table
```

The response is paged, so follow its `nextLink` if a model you deploy doesn't appear. The Models
API names the stages differently from the docs and the portal. The API's
`Deprecating` is what the docs call Deprecated (still serving, closed to new subscriptions), and
the API's `Deprecated` means Retired. Microsoft's own advice is to also compare
`deprecation.inference` with today's date, because `lifecycleStatus` can lag. A check that alerts
on `Deprecated` alone fires after the model is already gone.

Deployment names hide the model. A deployment called `chat-prod` tells you nothing, so record the
model and version next to every deployment name your code, Terraform and eval harness use.

## Step 2: Decide what each deployment should do on the date

For each Standard deployment on a retiring version, pick one of two paths:

- **Let it auto-upgrade, deliberately.** Fine for internal tools where an endpoint outage is worse
  than a behavior change. Know the target (`gpt-5.1` for `gpt-4o`) and its own July 13, 2027 date.
- **Migrate it yourself before the date.** For anything customer-facing, deploy the target model as
  a new deployment, test it, and move traffic yourself. You choose the model, the
  `reasoning_effort` and the day.

If you take the second path, set `versionUpgradeOption` to `NoAutoUpgrade` on the old deployment
only if you'd rather have requests fail loudly than be silently answered by a model you didn't
test. Microsoft's docs note that the Azure CLI can show the setting but can't change it; use the
portal, the REST API or Azure PowerShell.

Provisioned deployments get no automatic path at all. Plan an in-place migration, which Microsoft
says moves traffic over a 20 to 30 minute window without downtime, or a side-by-side one, and
confirm you have PTU quota for the target model before the date.

## Step 3: Record a baseline while the old version still answers

After the retirement date, the old version returns `410 Gone`, and with an auto-upgraded deployment
you can't even tell from the endpoint when it changed. Record real production inputs now, 100 to
300 per route, with the tools each one called, their arguments, the structured fields returned and
the refusals. That record is the only way to compare the new model against what your users actually
got. Log the `model` field of each response too: on Azure it normally carries the model name and
version, such as `o1-2024-12-17` in Microsoft's samples, which is how you see an upgrade land.

## Step 4: Deploy the target side by side and replay real traffic

Create a new deployment of the candidate, `gpt-5.1` or anything newer that is available in your
region and deployment type, next to the old one. Replay the recorded inputs through both and
compare per route:

- tool selection and arguments, compared deterministically, not by eye;
- structured output fields and refusals;
- the request errors from parameters the new model rejects;
- cost per request and reasoning tokens, at each `reasoning_effort` you are considering;
- latency at the percentiles you alert on.

For a reasoning model, sample each case more than once: the answers vary from run to run, and a
single pass can't tell a regression from noise.

## Step 5: Move traffic and remove the old version from every fallback

Switch one route at a time behind a flag, starting with the lowest-risk one. Remove the retiring
deployment from every fallback list and retry chain before the date, because a fallback to a
retired version fails exactly when you need it. Watch error rates, cost, latency and the response
`model` field for a week after each switch.

## Step 6: Put the next retirement date in CI

Every GA model on Azure has a retirement date from its first day, so the next migration is
already scheduled. Add a CI check that reads `deprecation.inference` from the Models API for every
model version you deploy and fails when one is less than 90 days away. Set up an Azure Service
Health alert on Azure OpenAI Service as well, since the email goes to subscription owners, who are
often not the engineers running the deployment.

## Doing this with EvalShift

Disclosure: I'm the founder of EvalShift, and steps 3 and 4 are the part it automates. The capture
SDK's `wrap_openai` wraps any OpenAI client, including one pointed at your Azure resource's
`/openai/v1/` endpoint, and records the deployment name you pass as `model`:

```python
from openai import OpenAI
from evalshift import capture
from evalshift.adapters.openai import wrap_openai

client = wrap_openai(
    OpenAI(base_url="https://my-openai-resource.openai.azure.com/openai/v1/", api_key=AZURE_KEY)
)

@capture.agent(suite="support", redact=True, tools=TOOLS)  # no-op unless EVALSHIFT_CAPTURE=1
def handle_ticket(message): ...
```

`compare` calls models through LiteLLM, which addresses an Azure deployment as
`azure/<deployment-name>` and reads `AZURE_API_KEY`, `AZURE_API_BASE` and `AZURE_API_VERSION`:

```bash
evalshift capture sync
evalshift compare --suite-name support --from azure/gpt-4o-prod --to azure/gpt-5-1-test
```

One limit as of EvalShift 1.6.2: tool-call scoring maps a model ID to the OpenAI, Anthropic or
Gemini response shape by its name, and `azure/` IDs aren't mapped yet, so a suite that offers tools
fails on them. Until that ships, run tool-calling suites against the same versions on OpenAI's API
while both still serve there, for example `--from gpt-4o-2024-08-06 --to gpt-5.1-2025-11-13`, and
smoke-test the Azure deployment itself before the switch. EvalShift sends `temperature=0`; when a
model rejects it, EvalShift resends without it and marks the run as non-deterministic in the
report, so set `defaults.samples_per_example` above 1 for the reasoning model. Docs:
[/docs/sdk-adapters](/docs/sdk-adapters), [/docs/captures](/docs/captures),
[/docs/migration-policy](/docs/migration-policy).

## FAQ

**When does GPT-4o retire on Azure OpenAI?** `gpt-4o` version 2024-05-13 retires on January 14,
2027, and versions 2024-08-06 and 2024-11-20 retire on April 14, 2027, together with `gpt-4o-mini`
2024-07-18. Regional Standard deployments of 2024-05-13 already retired on March 31, 2026.
Fine-tuned `gpt-4o` and `gpt-4o-mini` deployments keep serving until October 1, 2027.

**What happens to my Azure OpenAI deployment when its model retires?** Global Standard, Data Zone
Standard and Standard deployments are upgraded under the same deployment name, to the listed
replacement where it's offered for that deployment type and region, unless their upgrade policy is `NoAutoUpgrade`, in which case they stop working. Provisioned
deployments are never upgraded automatically and stop serving. A retired model version returns
`410 Gone` on every request.

**What replaces GPT-4o on Azure OpenAI?** Microsoft lists `gpt-5.1` for every `gpt-4o` version,
pinned to version 2025-11-13 for the January 14 retirement. It is a reasoning model whose `reasoning_effort` defaults to `none` on Azure, and
it retires on Azure on July 13, 2027. No replacement is listed yet for `gpt-4o-mini` or the GPT-4.1
models, which Microsoft usually names 90 to 120 days before the retirement date.

**Are Azure OpenAI retirement dates the same as OpenAI's?** No. Azure runs its own schedule. `gpt-4o`
2024-08-06, `gpt-4o-mini`, `gpt-4.1` and `gpt-4.1-mini` shut down on OpenAI's API on January 14,
2027 and on Azure on April 14, 2027, while `o3` and `o3-pro` were scheduled to retire on Azure on
November 19, 2026, before OpenAI's December 11 date.

**Can I get an extension on an Azure OpenAI model retirement?** No. Microsoft's lifecycle policy
says retirement dates aren't extendable. The only way to keep a workload running past the date is
to move it to a supported model version, or to accept the automatic upgrade on a Standard
deployment.

**Can a new Azure subscription still deploy gpt-4o?** Only the 2024-11-20 version, which is in the
Legacy stage, until Microsoft moves it to Deprecated. Version 2024-08-06, `gpt-4o-mini` and the GPT-4.1 models are Deprecated, which means
only subscriptions that have already deployed that exact version can create new deployments of
it, and a new subscription in the same tenant doesn't inherit that access.

**How do I find out about Azure OpenAI model retirements?** Subscription owners with active
deployments get an email at least 60 days before a GA model retires and 30 days before a preview
model does, and Azure Service Health shows advisories under Azure OpenAI Service. The Models API
returns each model's `lifecycleStatus` and `deprecation.inference` date, which a CI check can read.

## Keep reading

- [LLM model deprecation schedule 2026](/blog/llm-model-deprecation-schedule) — every OpenAI,
  Anthropic, Google, Azure and Bedrock shutdown date side by side.
- [GPT-4o and GPT-4.1 API shutdown on January 14, 2027](/blog/gpt-4o-gpt-4-1-deprecation) — the
  OpenAI side of the same models, and the move to `gpt-6-luna`.
- [How to catch LLM regressions before a model upgrade ships](/blog/llm-regression-testing-model-upgrade)
  — step 4 in full, with code and the failures it caught.
- [What actually breaks when you switch LLMs](/blog/what-breaks-when-you-switch-llms) — why the
  worst regressions from a model swap read as correct.
- [LLM drift](/blog/llm-drift) — how a model can change under a name you never edited.
