# Catch a model deprecation before the vendor email arrives

URL: https://infro.io/blog/catch-a-model-deprecation-before-the-vendor-email-arrives
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-13
Last modified: 2026-11-13
Last reviewed: 2026-11-13 (next review due 2026-12-13)
Topic: Architecture and migration
Format: Guide

> Run a daily job that pulls each vendor's machine-readable model data and deprecation page, normalizes ids, joins them to an inventory of the models your code and traffic use, and files a dated ticket against the owner. Your calendar and playbook stay the human layer; this job feeds them.

Key takeaways:
- Vendor notices go to the account owner, so the only reliable signal for the team that wrote the call is a job you run against the vendor's own pages and APIs.
- OpenAI exposes an optional shutdown_date on its model list, and Azure exposes lifecycle and deprecation fields on its Models API; use those before scraping any page.
- The hard part is the join: normalize snapshot suffixes, treat unpinned aliases as the earliest matching date, and compare per host, because the same model can retire on different dates on different providers.
- A hit is only useful when it carries an owner, a date and a severity, so build the owner lookup from call sites and gateway keys, and make ticket creation idempotent.
- Make the job fail loudly when a parser returns zero rows, or a changed page will look like good news.

## Why the notice reaches the wrong person

A deprecation notice is addressed to an account, not to a codebase. OpenAI says it notifies customers who are actively using the model by email and documents the change on its deprecations page.[1] Microsoft sends the GA retirement notice at least 60 days before retirement, to subscription owners with active deployments.[2] In most companies the person who owns the account or subscription is not the engineer who wrote the call, and not the team that still runs a nightly job against `gpt-4o-mini`.

The fix is not a better inbox rule. The vendors already publish the same facts in places a script can read, and your side of the join (which model ids you send, and who owns them) is data you hold. A scheduled check does the join every day and turns each hit into a ticket with an owner and a date.

This is the piece the usual artifacts do not automate. A [deprecation calendar](https://infro.io/blog/ai-model-deprecation-calendar) is a human-maintained list, and a [migration playbook](https://infro.io/blog/model-deprecation-migration-playbook) says what to do once you know. Neither tells you that a service you forgot about calls an id that appeared on a vendor page this morning.

## What the check has to do

Keep the job small and make each stage testable on its own.

1. **Inventory**: list every model id your applications call, with an owner and a source (repo, config, gateway key).
2. **Collect**: pull each vendor's lifecycle data, preferring APIs over pages.
3. **Normalize**: reduce ids to a comparable form.
4. **Join**: match inventory rows to vendor rows, per host.
5. **Score**: turn the shutdown date into a severity.
6. **File**: open or update one ticket per owner and model, and stay quiet when nothing changed.

The ordering matters because failures are different at each stage. A bad inventory gives you silence about a model you really use. A bad parser gives you silence about everything. A bad join gives you false alarms, which teach people to ignore the channel. The sections below take the stages in that order of risk.

## Build the inventory from two sides

Static scanning and traffic data each miss things the other catches, so use both.

**Static**: grep repositories, configuration, infrastructure code and prompt files for model id strings. This finds code paths that have not run recently, such as a quarterly report job. It misses ids assembled at runtime or read from a database.

**Observed**: read the model field from your request logs for the last 30 days. This finds the dynamic cases and the forgotten service that still runs. It misses anything that has not sent a request in the window. If your traffic goes through a gateway, an export of the request log gives you model, key and project per request; INFRO's request log export and per-request usage record exactly those fields.

Write both into one file with one row per (model id, caller):

```json
{"model": "gpt-4o-2024-08-06", "host": "openai", "owner": "team-search", "source": "gateway-key:search-prod"}
{"model": "gpt-4o", "host": "azure-openai", "owner": "team-support", "source": "repo:support-bot/config.yaml"}
```

Record the **host** next to the id. The same model name retires on different dates depending on where you call it, and the join in a later section depends on that. Record unpinned aliases as they appear (`gpt-4o`, not a guess at a snapshot), because an alias is itself a finding; see [aliases versus pinned snapshots](https://infro.io/blog/model-aliases-vs-pinned-snapshots).

## Collect from APIs first, pages second

Prefer a field that returns a date over a table you have to parse.

**OpenAI.** The deprecations page recommends monitoring programmatically by calling `GET /v1/models` and checking each model's optional `shutdown_date` field, which is also on the retrieve-a-model endpoint.[1] Because the field is optional, its absence means "no date published on this endpoint", not "safe". Also read the page itself: it carries a table of shutdown date, affected model, status, recommended replacement and notice date, a separate table for feature and endpoint deprecations, and a note that fine-tuned versions follow the schedule of their base model.[1] The page has a markdown version at the same address with `.md` appended, which is easier to parse than the rendered HTML.

**Azure OpenAI and Foundry.** Microsoft says you can check `lifecycleStatus`, `deprecation` and per-SKU `deprecationDate` for any model through the Models API, scoped to a subscription and a region.[2] The REST reference lists a List operation for it.[3] The retirement schedule page is the human-readable twin, with lifecycle, retirement date and replacement per model and version.[4] Use the API as the source of truth and the page as a cross-check.

**Other vendors.** Add each one the same way: look for a list endpoint with a date field, fall back to a page. For a vendor whose page you cannot parse reliably, store a hash of the deprecation table and open a review task when it changes.

```python
import re, datetime as dt, urllib.request

DATE_ROW = re.compile(r"^\|\s*\*\*(?P<date>[A-Z][a-z]{2} \d{1,2}, \d{4})\*\*\s*\|(?P<ids>[^|]*)\|", re.M)
TICKS = re.compile(r"`([^`]+)`")

def openai_page_rows(md: str):
    rows = []
    for m in DATE_ROW.finditer(md):
        shutdown = dt.datetime.strptime(m["date"], "%b %d, %Y").date()
        for mid in TICKS.findall(m["ids"]):
            rows.append({"host": "openai", "id": mid, "shutdown": shutdown})
    return rows

def fetch(url, headers=None):
    req = urllib.request.Request(url, headers=headers or {})
    with urllib.request.urlopen(req, timeout=30) as r:
        return r.read().decode()

md = fetch("https://developers.openai.com/api/docs/deprecations.md")
rows = openai_page_rows(md)
# Fail loudly: a layout change must not look like "nothing is retiring".
assert len(rows) >= 10, f"parser returned {len(rows)} rows; page layout changed?"
```

The assertion at the end is the most important line. A table that moves, gains a column or becomes a script-rendered widget will make the regex match nothing, and a job that reports "0 hits" will look healthy.

## Normalize, then join per host

Vendors write ids in several shapes: a family label with snapshots in parentheses, a dated snapshot, a bare alias. OpenAI's table, for example, lists GPT-4o as a family label with the snapshot ids `gpt-4o-2024-08-06` and `gpt-4o-2024-11-20` beside it.[1] Azure lists a model name and a version in separate columns.[4] Reduce everything to a `(base, snapshot)` pair and match on the base when your inventory holds an alias.

```python
import re, datetime as dt

SNAP = re.compile(r"-(\d{4}-\d{2}-\d{2})$")

def split_id(model_id: str):
    name = model_id.lower().split("/")[-1]
    m = SNAP.search(name)
    return (SNAP.sub("", name), m.group(1) if m else None)

def match(inv, vendor_rows):
    base, snap = split_id(inv["model"])
    hits = []
    for r in vendor_rows:
        if r["host"] != inv["host"]:
            continue                      # never compare across hosts
        rbase, rsnap = split_id(r["id"])
        if rbase != base:
            continue
        if snap is None or rsnap is None or snap == rsnap:
            hits.append(r)
    # An unpinned alias is exposed to the earliest matching shutdown.
    return min(hits, key=lambda r: r["shutdown"]) if hits else None
```

Two rules in that function come from the vendors' own data.

**Compare per host.** The same model can retire on different dates on different providers. OpenAI lists `gpt-4o-2024-08-06` and `gpt-4o-2024-11-20` shutting down on Jan 14, 2027,[1] while Azure's schedule has those versions retiring on April 14, 2027, and `gpt-4o` version 2024-05-13 on January 14, 2027.[4] A join that ignores host reports the wrong date for one of your two callers. Azure also distinguishes deployment types: Global Standard and Data Zone Standard deployments are auto-upgraded at retirement while provisioned deployments are not.[2] Carry the deployment type in the inventory if you use more than one.

**Treat aliases as the earliest date.** If an app sends `gpt-4o` with no snapshot, it is exposed to whichever snapshot goes first.

Beware of Azure deployment names. A deployment is a name you chose, and it may not equal the model name. Resolve each deployment to its model and version through the Azure control plane before the join, or the inventory will list a name no vendor row will ever match.

## Turn a hit into an owner, a date and a severity

A match is not yet actionable. The ticket needs three things.

**Owner.** Resolve in this order: the gateway key or project owner for observed traffic, then `CODEOWNERS` for the file where the static scan found the id, then the service catalog entry. If nothing resolves, route the ticket to the platform team's own queue so that the unowned case is visible, not dropped.

**Date.** Use the shutdown date from the vendor row, and keep the status and replacement in the ticket body. Notice windows differ, which is why one threshold does not fit every id. OpenAI states minimum notice of at least 6 months for generally available models, at least 3 months for specialized variants and image generation models, and possibly as little as 2 weeks for preview models.[1] Microsoft gives at least 60 days for GA retirement and at least 30 days for preview.[2]

**Severity.** Base it on days remaining and on whether the id is a preview:

```python
def severity(days_left: int, preview: bool) -> str:
    if days_left <= 0:
        return "shut-down"          # already failing or refused
    if preview:
        return "critical" if days_left <= 30 else "warning"
    if days_left <= 14:
        return "critical"
    if days_left <= 60:
        return "warning"
    return "info"
```

Make filing idempotent. Key each ticket on `(host, base id, shutdown date)` and update it when the date or replacement changes. A re-run must neither duplicate tickets nor stay silent when a vendor moves a date earlier. Re-notify when severity steps up, not on every run.

> **Example: Illustrative output of one run**
> The owners and ticket ids below are invented; the vendor dates come from the pages read for this guide.
> 
> ```text
> WARNING  team-support  azure-openai  gpt-4o (unpinned)  earliest match 2027-01-14  replacement per Azure: gpt-5.1
>          source: repo:support-bot/config.yaml   ticket: PLAT-1042 (created)
> INFO     team-search   openai        gpt-4o-2024-08-06  shutdown 2027-01-14        replacement per OpenAI: gpt-6-luna
>          source: gateway-key:search-prod        ticket: PLAT-1043 (created)
> UNOWNED  -             openai        whisper-1          shutdown 2027-02-26        replacement per OpenAI: gpt-live-transcribe or gpt-transcribe
>          source: observed traffic, no key owner ticket: PLAT-1044 -> platform queue
> ```

## Failure modes to design against

- **Silent parser breakage.** Covered above: assert a minimum row count and alert when it drops. Also alert when a vendor's source is unreachable for several consecutive runs.
- **Dates that move.** Microsoft notes the schedule is subject to change and that its replacement is chosen roughly 90–120 days before retirement,[2] so a ticket created early may name no replacement yet. Update rather than close.
- **Unversioned ids and family labels.** A hit on a family label with no snapshot match is still a hit; file it for review.
- **Fine-tunes.** OpenAI says fine-tuned versions follow their base model's schedule.[1] Microsoft retires fine-tuned training and deployment in separate phases.[4] Add fine-tune ids to the inventory explicitly; they will not look like the base name.
- **Non-model deprecations.** Endpoints and features retire too: OpenAI's page lists prompt objects, Agent Builder, audio translations and fine-tuning job creation on their own dates.[1] Inventory the features you call, not only the models.
- **Alert fatigue.** Notify on change and on severity step-ups only. A daily digest of everything still open belongs in the weekly review, not the on-call channel.

## What a gateway already covers, and what it does not

If your calls pass through INFRO, part of this is already recorded for you. INFRO records each vendor's deprecations, shutdown dates and recommended replacements from the vendor's own page; `GET /v1/models` carries a `retirement` object, and an organization that sent a retiring model in the last 30 days gets a `model.retiring` alert naming the keys and projects that called it.[5] The alert fires when a model the organization sent is shut down by its vendor within 60 days, and is critical in the last 7 days.[6] INFRO also reads the model list your own key returns every three hours and stops offering a model the key has stopped listing, and the console shows these notices under the bell. See the [models and lifecycle docs](https://infro.io/docs/models) for the exact fields.

That covers traffic that goes through the gateway. It does not read your repositories, calls that bypass the gateway, or your Azure deployment names, and INFRO records a vendor's retirement for a partner cloud only when that cloud's own date is recorded.[5] So the scheduled job in this guide still earns its place: it covers the static inventory and the owner mapping, and it can ingest the gateway's retirement data as one more source instead of scraping the same pages twice.

## A rollout checklist

- [ ] Static scan of repos and config produces `(model, host, owner, source)` rows.
- [ ] Request-log export produces the same rows from the last 30 days.
- [ ] Azure deployment names are resolved to model and version.
- [ ] OpenAI `GET /v1/models` `shutdown_date` and the deprecations page are both read.
- [ ] Azure Models API lifecycle fields are read and cross-checked with the schedule page.
- [ ] Each collector asserts a minimum row count and alerts when a source is unreachable.
- [ ] Join is per host; unpinned aliases map to the earliest matching date.
- [ ] Tickets are keyed on `(host, base id, shutdown date)` and updated, not duplicated.
- [ ] Unowned hits go to the platform queue, never to nobody.
- [ ] Each ticket links to your [migration playbook](https://infro.io/blog/model-deprecation-migration-playbook) and the calendar entry.

## Questions

### How often should the check run?

Daily is enough for the vendors' notice periods described here, which are measured in weeks to months. Run it more often only for preview ids, where OpenAI says notice can be as short as two weeks [1].

### What if a vendor has no machine-readable lifecycle data?

Fetch the deprecation page, store a hash of the table text, and treat any change as a review task rather than parsing it. A page diff that opens a human ticket still beats learning from someone else's inbox.

## Sources

1. Deprecations (markdown version) — OpenAI. https://developers.openai.com/api/docs/deprecations.md (accessed 2026-11-13)
2. Microsoft Foundry Models lifecycle and support policy — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirements (accessed 2026-11-13)
3. Models - REST API (Azure AI Services) — Microsoft Learn. https://learn.microsoft.com/en-us/rest/api/aiservices/accountmanagement/models?view=rest-aiservices-accountmanagement-2024-10-01 (accessed 2026-11-13)
4. Model retirement schedule — Microsoft Learn. https://learn.microsoft.com/en-us/azure/foundry/openai/concepts/model-retirement-schedule (accessed 2026-11-13)
5. Models: IDs and lifecycle — INFRO. https://infro.io/docs/models (accessed 2026-11-13)
6. Alerts — INFRO. https://infro.io/docs/observability/alerts (accessed 2026-11-13)
