Seven Dates, One Bill

TL;DR.

Between October 31 and January 14, seven scheduled changes reprice the models most production stacks run on. None of them needs you to do anything. That's the problem: on five of the seven, doing nothing or accepting the provider's named replacement makes the same request cost more.

• Two introductory prices end. Gemini 4 Argon doubles on December 1, from $2/$10 to $4/$20 per million tokens, which is Opus 5.5's price. Gemini 3.8 Flash and 3.6 Flash double on January 1, to $1.50/$7.50.
• One promotion can end. OpenAI says GPT-5.6 Sol's $4/$20 price runs "at least through November 21." The stated discount implies $5/$30 after it, 36% more per chat request.
• Two retirement waves hit OpenAI. On December 11, gpt-5, gpt-5-mini, gpt-5-nano, o3 and the pro variants shut down. The named replacement for gpt-5-mini, gpt-5.6-terra, costs 6.9x as much per request. GPT-6 Luna costs 69% less. On January 14, gpt-4o, gpt-4o-mini, gpt-4.1 and gpt-4.1-mini follow, and their replacement, GPT-6 Luna, cuts the price 72% to 96%, with a tier drop you have to test.
• Claude Sonnet 4.5 retires November 30. Sonnet 5.5 costs a third less per token but produces about 30% more tokens for the same text, so a chat request costs 13% less, not 33%.
• DeepSeek's free searches end October 31 at 16:00 UTC: $0.75 per 1,000 successful Search or Fetch calls, still 13x cheaper than Claude's web search.
• On a sample six-model stack, autopilot raises the monthly bill 63% by January 14. Re-pricing each line to the cheapest listed candidate cuts it 65%, if the candidates pass your evals. Below is repricing.py, 77 lines that run the same calendar on your own usage export.

Dates and prices are from the OpenAI, Anthropic, Google and DeepSeek pricing and deprecation pages, retrieved October 28, 2026. The request shapes and the sample stack are ours, and are illustrations, not measurements. No figure here comes from Nadir customer data.

The calendar.

USD per million input / output tokens. On the Gemini rows, cached-input prices move with the base price: Argon's goes from $0.10 to $0.20, Flash's from $0.075 to $0.15, and Flash's explicit-cache storage from $0.50 to $1.00 per million tokens per hour.

Two details in the sources change the math.

The Sol number after November 21 isn't published. OpenAI's page says the promotion runs "at least through November 21, 2026" and describes it as "a 20% reduction in input pricing and a 33% reduction in output pricing." Undoing those gives $5 input and $30 output. That's our inference, and OpenAI could extend the promotion. Budget for the list price anyway.

Fine-tunes retire with their base model. OpenAI's deprecations page says fine-tuned versions follow the base model's shutdown schedule. A fine-tuned gpt-4o-mini stops working on January 14 along with the base, and you can't move it by changing a string. The training data has to be run again on a model that stays.

What each date does to a request.

Per-token prices don't tell you what a request costs. We priced two shapes on each change. A chat request is 3,000 uncached input tokens and 500 output. An agent turn is 2,000 uncached input, 48,000 cached input and 1,000 output.

List prices as of October 28, 2026. The "better-priced option" is the cheapest same-tier model we'd put through an eval, not a recommendation for your workload.

Three patterns show up in that table.

1. The named replacement is a default, not a price check.

OpenAI's December 11 replacements were written on June 11, before GPT-6 shipped. They point at the GPT-5.6 family, and the cheapest GPT-5.6 option is no longer the cheapest option. gpt-5-mini to gpt-5.6-terra is the worst row on the calendar: 8x the input price and 6x the output, for a model that has no GPT-6 successor and that GPT-6 Sol already matches on price. We covered the same pattern for the October 23 wave in The Replacement Is a Raise. It hasn't gone away. It moved to December.

Not every retirement has a cheaper exit. gpt-5 was priced at $1.25/$10, and the cheapest current model in its tier, GPT-6.1 Sol at $2/$10, still costs 26% more on a chat request. On an agent turn the gap is 2%, because Sol's cached input is $0.10 against gpt-5's $0.125. When there's no like-for-like discount, the remaining lever is sending fewer requests to that tier at all.

2. An introductory price is a scheduled raise.

Argon at $2/$10 is the same price as Sonnet 5.5 and GPT-6.1 Sol. On December 1 it becomes $4/$20, the same price as Opus 5.5. Nothing about the model changes that day. What changes is which tier you're paying for. Teams that picked Argon in October because it matched Sonnet on price will be paying Opus prices for it in December, unless they re-run that comparison.

Gemini 3.8 Flash is the same story one step down. At $1.50/$7.50 from January 1, its output costs 15x GPT-6 Luna's or Haiku 5.5's $0.50. That's fine if Flash is what clears your quality bar. It's a lot to pay for inertia.

Introductory prices do get extended. Sonnet 5's did, three weeks before its scheduled end. Neither Google page says anything like that today, so plan on the dates as written.

3. Some forced migrations are the biggest cut you'll get, if the smaller model holds.

gpt-4o to GPT-6 Luna is a 96% cut on a chat request. It's also a move from a 2024 flagship to a 2026 small model. Luna is newer and likely stronger on plenty of tasks gpt-4o was doing, but "likely" isn't a test. Run your eval set on Luna before January 14. If part of the traffic fails, route that part to GPT-6.1 Sol and keep the rest on Luna. Splitting the traffic usually beats picking one model for all of it.

Sonnet 4.5 to Sonnet 5.5 is the subtle one. The per-token price falls a third, and Anthropic's pricing page says the newer tokenizer "produces approximately 30% more tokens for the same text," with the exact increase depending on content. On our shapes, that turns a 33% token price cut into a 13% cut per chat request. Agents do better, at 31%, because Sonnet 5.5's cache reads are priced at 0.05x input instead of 0.1x.

The search line.

DeepSeek's Search and Fetch APIs bill $0.75 per 1,000 successful requests from 00:00 Beijing time on November 1, which is 16:00 UTC on October 31. Until then, server-side search calls made through DeepSeek's harness, Claude Code or Codex are free. Only HTTP 200 responses with usable results count. Failed calls, empty results and timeouts aren't billed, and the count parameter doesn't change the price.

That's still cheap. Claude's server-side web search costs $10 per 1,000 searches plus the result tokens, about 13x more per call. The risk is volume you never priced because it was free: an agent loop that searches before every step makes thousands of calls a day, and none of them showed up on an invoice before Saturday. If you pointed a coding agent at DeepSeek's endpoint this month, count its search calls per task now. The Search Tax has the per-task math for agent search.

One stack, six invoices.

Take a sample stack spending $7,215 a month across six models: gpt-5-mini for support, a legacy gpt-4o summarizer, an agent on GPT-5.6 Sol, a coding agent on Sonnet 4.5, Argon for analysis and Gemini 3.8 Flash for extraction. Price the same monthly traffic on each date.

Autopilot, meaning accept every named replacement and let every promo lapse, ends at $11,744, up 63%. December 11 does most of the damage: gpt-5-mini traffic moves to gpt-5.6-terra and that one line goes from $800 a month to $5,440. January 14 brings part of it back, because gpt-4o moves to Luna.

The re-priced path moves each line to the cheapest candidate on its list and ends at $2,536, 65% below today. Treat that as a floor. It assumes gpt-5-mini traffic holds on Luna, Argon's analysis holds on GPT-6.1 Sol, and Flash extraction holds on Haiku 5.5. Some of those will fail on some requests. The realistic answer lands between the two lines, and per-request evals tell you where.

Tutorial: repricing.py.

repricing.py takes a monthly usage export, one row per model, and prices it on each date with the rate card in effect that day. When a model is retired on that date, it bills the provider's named replacement, so the first table is the autopilot path. The second table prices each row on the last date at the named replacement and at the cheapest candidate you listed for it.

"""repricing.py: price your monthly token mix on every Q4 2026 repricing date.

usage.csv has one row per model: model,input_m,cached_m,output_m (millions of
tokens a month). Retired models are priced at the provider's named replacement
("autopilot"), and each row also shows the cheapest candidate you listed.
"""
import csv
import sys

# USD per 1M tokens: (input, cached input, output). None = retired.
RATES = {
    "gpt-5":             [("2025-08-07", (1.25, 0.125, 10.0)), ("2026-12-11", None)],
    "gpt-5-mini":        [("2025-08-07", (0.25, 0.025, 2.0)), ("2026-12-11", None)],
    "gpt-4o":            [("2024-08-06", (2.50, 1.25, 10.0)), ("2027-01-14", None)],
    "gpt-4.1-mini":      [("2025-04-14", (0.40, 0.10, 1.60)), ("2027-01-14", None)],
    "gpt-5.6-sol":       [("2026-07-01", (4.00, 0.40, 20.0)),
                          ("2026-11-22", (5.00, 0.50, 30.0))],  # promo end, implied list
    "gpt-5.6-terra":     [("2026-07-01", (2.00, 0.20, 12.0))],
    "gpt-6.1-sol":       [("2026-10-01", (2.00, 0.10, 10.0))],
    "gpt-6-luna":        [("2026-09-22", (0.10, 0.01, 0.50))],
    "claude-sonnet-4-5": [("2025-09-29", (3.00, 0.30, 15.0)), ("2026-11-30", None)],
    "claude-sonnet-5-5": [("2026-09-28", (2.00, 0.10, 10.0))],
    "claude-haiku-5-5":  [("2026-10-07", (0.10, 0.01, 0.50))],  # prompts <= 100K
    "gemini-4-argon":    [("2026-10-13", (2.00, 0.10, 10.0)),
                          ("2026-12-01", (4.00, 0.20, 20.0))],
    "gemini-3.8-flash":  [("2026-10-01", (0.75, 0.075, 3.75)),
                          ("2027-01-01", (1.50, 0.15, 7.50))],
    "gemini-3.5-flash-lite": [("2026-06-01", (0.30, 0.03, 2.50))],
}
REPLACEMENT = {"gpt-5": "gpt-5.6-sol", "gpt-5-mini": "gpt-5.6-terra",
               "gpt-4o": "gpt-6-luna", "gpt-4.1-mini": "gpt-6-luna",
               "claude-sonnet-4-5": "claude-sonnet-5-5"}
# Same-tier options you would eval before switching. Edit for your workloads.
CANDIDATES = {"gpt-5": ["gpt-6.1-sol"], "gpt-5-mini": ["gpt-6-luna"],
              "gpt-5.6-sol": ["gpt-6.1-sol"], "gemini-4-argon": ["gpt-6.1-sol", "claude-sonnet-5-5"],
              "gemini-3.8-flash": ["gemini-3.5-flash-lite", "claude-haiku-5-5"],
              "claude-sonnet-4-5": ["gpt-6.1-sol"]}
TOKENS = {"claude-sonnet-5-5": 1.30}  # newer Claude tokenizer, about 30% more tokens
DATES = ["2026-10-28", "2026-11-22", "2026-12-01", "2026-12-11", "2027-01-01", "2027-01-14"]


def rate(model, day):
    """(model actually billed, rates) on day, following retirements."""
    card = [r for d, r in RATES[model] if d <= day][-1]
    return (model, card) if card else rate(REPLACEMENT[model], day)


def cost(row, model, card, src):
    k = TOKENS.get(model, 1.0) / TOKENS.get(src, 1.0)
    i, c, o = (float(row[x]) * k for x in ("input_m", "cached_m", "output_m"))
    return i * card[0] + c * card[1] + o * card[2]


def main(path):
    rows = list(csv.DictReader(open(path, newline="")))
    print("date        autopilot bill   change")
    first = None
    for day in DATES:
        total = sum(cost(r, *rate(r["model"], day), r["model"]) for r in rows)
        first = first or total
        print(f"{day}  ${total:>12,.0f}   {total / first - 1:+6.1%}")
    print(f"\non {DATES[-1]}:  billed as            autopilot   cheapest candidate")
    totals = [0.0, 0.0]
    for r in rows:
        billed, card = rate(r["model"], DATES[-1])
        auto = cost(r, billed, card, r["model"])
        opts = [(cost(r, m, rate(m, DATES[-1])[1], r["model"]), m)
                for m in CANDIDATES.get(r["model"], [])]
        best = min(opts + [(auto, billed)])
        totals[0] += auto
        totals[1] += best[0]
        print(f"  {r['model']:<18} {billed:<18} ${auto:>9,.0f}   ${best[0]:>9,.0f} {best[1]}")
    print(f"  {'total':<37} ${totals[0]:>9,.0f}   ${totals[1]:>9,.0f}")


if __name__ == "__main__":
    main(sys.argv[1])

The sample stack as a usage file:

model,input_m,cached_m,output_m
gpt-5-mini,800,1200,300
gpt-4o,300,200,60
gpt-5.6-sol,200,600,40
claude-sonnet-4-5,150,2400,30
gemini-4-argon,100,100,20
gemini-3.8-flash,600,200,120

python3 repricing.py usage.csv prints:

date        autopilot bill   change
2026-10-28  $       7,215    +0.0%
2026-11-22  $       7,875    +9.1%
2026-12-01  $       7,757    +7.5%
2026-12-11  $      12,367   +71.4%
2027-01-01  $      13,282   +84.1%
2027-01-14  $      11,744   +62.8%

on 2027-01-14:  billed as            autopilot   cheapest candidate
  gpt-5-mini         gpt-5.6-terra      $    5,440   $      242 gpt-6-luna
  gpt-4o             gpt-6-luna         $       62   $       62 gpt-6-luna
  gpt-5.6-sol        gpt-5.6-sol        $    2,500   $      860 gpt-6.1-sol
  claude-sonnet-4-5  claude-sonnet-5-5  $    1,092   $      840 gpt-6.1-sol
  gemini-4-argon     gemini-4-argon     $      820   $      410 gpt-6.1-sol
  gemini-3.8-flash   gemini-3.8-flash   $    1,830   $      122 claude-haiku-5-5
  total                                 $   11,744   $    2,536

How to adapt it:

1. Build the usage file from the providers' exports. Anthropic's Console usage export breaks spend down by API key and model, which is also how its deprecation page says to find retiring models. OpenAI's usage dashboard and Google's billing export give the same split. Use uncached input, cached input and output as separate columns, because the cache line is where the prices differ most.
2. Add every model you run. The rate table only has what the sample needs. Add gpt-5-nano ($0.05 / $0.005 / $0.40, retires December 11 to gpt-5.6-luna), o3 ($2 / $0.50 / $8, to gpt-5.6-sol), gpt-4.1 ($2 / $0.50 / $8) and gpt-4o-mini ($0.15 / $0.075 / $0.60), both to gpt-6-luna on January 14.
3. Keep the candidates honest. CANDIDATES is where judgment lives. List models you'd actually put through an eval for that workload, and remember that a cross-provider switch also means a cold prompt cache and a different tokenizer.
4. Check the tokenizer factor. 1.3 is Anthropic's approximate figure for the newer Claude tokenizer, and the real ratio depends on your content. Code and non-English text tend to land higher. Run count_tokens on a sample of your prompts on both models and use your ratio.
5. Re-run it on November 22. If OpenAI extends the Sol promotion or publishes a different list price, change one row.

A checklist for this week.

1. Grep for the retiring IDs. gpt-5, gpt-5-mini, gpt-5-nano, o3, gpt-4o, gpt-4o-mini, gpt-4.1, gpt-4.1-mini and claude-sonnet-4-5, including config files, environment variables, eval harnesses and fine-tune jobs. Aliases count: gpt-4o resolves to a dated snapshot that's on the list.
2. Export usage by model and run repricing.py. You want the rows where autopilot raises the price, sorted by dollars.
3. Run your eval set on the candidates for the top three rows. Start with the December 11 rows. They have the largest price jumps and the shortest runway.
4. Count DeepSeek search calls per task if any agent uses DeepSeek's server-side search.
5. Re-run the comparison behind every model you chose for its introductory price, before December 1 for Argon and before January 1 for Flash.
6. Put Claude Haiku 4.5 and Opus 4.5 on a watch list. Anthropic lists their tentative retirement dates as "not sooner than" October 15 and November 24, 2026, and gives at least 60 days' notice. Neither is deprecated yet, but both dates have passed or are close.

Where Nadir fits.

repricing.py prices the calendar once. A router makes the same decision on every request, against the current rate cards.

The model name moves out of the code. With model="auto", Nadir sends each prompt to the cheapest model in your configured set that clears the quality floor you set on the API key. When gpt-5-mini retires or Argon's price doubles, you change the configured set, not every service that calls it. Each response reports which model served it and what it cost, so the per-model split in the tutorial exists for every request without a separate export.

Routing is the answer to "some of it fails on Luna." The re-priced line in the stack chart assumes every request holds on the cheaper model. Per-request routing doesn't need that assumption: the simple share goes to the small tier and the rest stays on a stronger one. That's usually the gap between the floor and what you'd actually save.

If you'd rather measure before anything changes, Observe mode serves exactly the model you asked for and records what routing would have chosen. With your own provider keys, Nadir charges no fee on any plan, and the provider bills you directly. Savings depend on your workload, and nothing in this post forecasts yours.

Start with a free key, or run repricing.py on last month's usage first and see which of the seven dates is yours.

Conclusion.

Seven dates in eleven weeks: a search fee, a promo that can end, two introductory prices that double, and three retirement waves. On the default path, five of them raise the price of a request, with the worst at 6.9x, and two lower it, with the biggest cut coming from a forced move to a smaller model. Nothing in this calendar requires you to act, which is why the bill will change in January for teams that didn't. Price your own mix on each date, test the candidates for the rows that go up, and make the model choice somewhere you can change it in one place.

Retirement dates and named replacements are from [OpenAI's deprecations page](https://developers.openai.com/api/docs/deprecations) and [Anthropic's model deprecations page](https://platform.claude.com/docs/en/about-claude/model-deprecations). OpenAI prices, including the GPT-5.6 Sol promotion wording, are from [OpenAI's API pricing](https://developers.openai.com/api/docs/pricing) and the [GPT-5.6 Sol model page](https://developers.openai.com/api/docs/models/gpt-5.6-sol). The post-promotion $5/$30 is our inference from the stated 20% and 33% reductions, not a published price. Claude prices and the tokenizer note are from [Anthropic's pricing page](https://platform.claude.com/docs/en/about-claude/pricing), with Haiku 5.5 at its rate for prompts up to 100K tokens. Gemini prices and introductory end dates are from [Google's Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing). DeepSeek's Search and Fetch pricing is from [DeepSeek's Search API guide](https://api-docs.deepseek.com/guides/search). [Tokencost's October 2026 price-change roundup](https://tokencost.app/blog/llm-api-price-changes-october-2026) pointed us to several of these dates. All prices were retrieved October 28, 2026, in USD, standard tier, short context. The request shapes and the sample stack are ours, and are illustrations, not measurements.