OpenAI Is Closing Fine-Tuning in January 2027. Here Is Where to Train Instead

#python #machinelearning #opensource #ai

Go and read OpenAI's deprecations page. Not a blog post about it, the page itself, dated 7 May 2026. If your organisation has never run a fine-tuning job, you cannot start one. Since 2 July 2026, new jobs need inference on a fine-tuned model within the previous 60 days. On 6 January 2027 that door shuts for everybody, and fine-tuned gpt-3.5-turbo, gpt-4, gpt-4.1-nano, babbage-002 and davinci-002 go dark on 23 October 2026.

I put together the full comparison on DevToolLab with every price sourced from the provider's own page. This is the compressed version, because the headline deserves to travel: the most visible fine-tuning API in the industry is being retired while every alternative got cheaper and better in the same twelve months.

Behaviour, Not Facts

Before shopping for a platform, be sure you need one. Fine-tuning changes how a model behaves. It does not install knowledge. "The model has never heard of our internal billing API" is a retrieval problem. "The model understands the task but keeps returning prose when I asked for JSON, or picks the wrong label out of six" is a fine-tuning problem, and prompt engineering will keep almost-fixing it forever.

One filter decides it: could you sit down and write 200 to 1,000 examples of the output you want? If the answer is no, stop here. Nothing on this list rescues a dataset you cannot describe.

Four methods, briefly. SFT learns from input and ideal-output pairs, and covers most real needs. DPO learns from pairs where one answer beats another, which suits taste-driven work like tone or summary quality. RFT, in practice GRPO, learns against a grader that scores attempts, so it fits problems you can measure but cannot hand-write, such as code that must pass a test suite. Distillation copies a big model's outputs into a small one purely to cut serving cost.

Why Everyone Reaches for LoRA

LoRA freezes the base weights and trains a small adapter beside them. The ratio is the whole story, and it is easy to see for yourself. This ran on my laptop against peft 0.20.0:

from transformers import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model

base = AutoModelForCausalLM.from_pretrained("HuggingFaceTB/SmolLM2-135M")
model = get_peft_model(base, LoraConfig(
    r=16, lora_alpha=32, task_type="CAUSAL_LM",
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
))
model.print_trainable_parameters()

trainable params: 1,843,200 || all params: 136,358,208 || trainable%: 1.3517

Under one and a half percent of the weights carry the training. At fp16 that adapter is 3.5 MiB against a 260 MiB model, which is why a single GPU can serve dozens of task-specific variants off one base.

The Big Clouds Are Not All Retreating

OpenAI's own model optimization guide now warns that its fine-tuning material is moving to legacy documentation, which tells you the same thing the deprecation table does. What still runs for existing customers: SFT and DPO on gpt-4.1, mini and nano, vision tuning on gpt-4o-2024-08-06, RFT only on o4-mini-2025-04-16. Training is $25 per million tokens on gpt-4.1, $5 on mini, $1.50 on nano, and RFT bills $100 per hour of core training. No GPT-5 model was ever fine-tunable, and the migration notes send you to untuned gpt-5.4-mini and gpt-5.5.

Microsoft went the other way with the same model family. Foundry runs RFT on o4-mini with Global Training across 13 regions at lower per-token rates than standard, the trade being data residency. GPT-4.1, mini and nano serve as graders, and Microsoft's own advice is to grade with nano first. If you need managed OpenAI-family tuning that is not on a shutdown schedule, this is the shortest move.

Google bills Vertex tuning as dataset tokens multiplied by epochs, then charges above base rates to serve the tuned endpoint, which is the part that surprises people at invoice time. Check which snapshot is actually tunable before you plan around it, since Gemini 3.x tuning has been arriving through preview and allowlist rather than open self-serve.

AWS made the most interesting bet by treating open weights as the main event. Bedrock added RFT for Qwen3-32B and gpt-oss-20b on 17 February 2026, and the tuned model answers immediately through OpenAI-compatible Responses and Chat Completions endpoints. SageMaker AI followed on 25 March 2026 with serverless SFT, DPO and RFT across twelve more open models including gpt-oss-120b and Qwen3 14B, in N. Virginia, Oregon, Tokyo and Ireland. Anthropic is the gap: no fine-tuning in the public Claude API at all, only Bedrock customisation on whichever Claude models it exposes.

The Specialists Compete on Price

Together AI is the number to benchmark everyone else against: $0.48 per million training tokens for LoRA up to 16B, $1.50 from 17B to 69B, $2.90 from 70B to 100B, with full fine-tuning and DPO also available. Fireworks AI opens at a near-identical $0.50 up to 16B but climbs to $3.00 by 80B and $6.00 by 300B, so the model size you actually intend to train decides which is cheaper, not the logo.

Tinker from Thinking Machines Lab is the one I would reach for if I wanted control without babysitting GPUs. It meters per million tokens instead of per GPU-hour, Qwen3-8B moved from $0.40 to $0.44 on 17 July 2026, so a 50 million token run lands near $22 plus $0.10 per GB-month of checkpoints. It only does LoRA at rank 32, and it exports a plain PEFT adapter, so leaving costs you nothing.

Predibase deserves a caveat more than a recommendation. GRPO runs $10 per million tokens to 16B and $20 from there to 32B, with generous free serverless inference, but it has belonged to Rubrik since June 2025 and predibase.com no longer serves its own site as of August 2026. It redirects to Rubrik Agent Cloud. Confirm the product is still sold on its own before you build a roadmap on it. The original post has the full pricing table for all of these side by side.

Or Skip the Bill Entirely

With one GPU, or a rented hour of one, the free tooling is the fastest path in the category. Unsloth 2026.8.3 is the throughput specialist: GRPO roughly 1.3x faster, mixture-of-experts training 3 to 5x faster, and up to 80 percent less VRAM on reinforcement learning, which is precisely what puts GRPO within reach of a consumer card. Axolotl 0.18.0 keeps every run in a YAML file, so a training change arrives as a reviewable diff instead of a notebook nobody can reproduce. LLaMA-Factory 0.9.5 claims the widest model surface at 100-plus and ships a UI. Underneath all of them sit TRL 1.9.2 and PEFT 0.20.0, which now expose SFT, DPO and GRPO trainers directly if you would rather own the loop.

What you inherit is the GPU, the CUDA versions and the evaluation harness. A sane split: rent a hosted platform to find out whether the idea works at all, then move in-house once the same job runs every week.

Check the Dataset Before the Meter Starts

Training is billed per token, so a broken JSONL file costs money before it costs you an experiment. This is short enough to paste into any repo, and the output below is a real run against a deliberately damaged six-row file:

import json, sys, tiktoken

enc = tiktoken.get_encoding("o200k_base")
rows = bad = tokens = 0

for n, line in enumerate(open(sys.argv[1], encoding="utf-8"), 1):
    if not line.strip():
        continue
    rows += 1
    try:
        msgs = json.loads(line)["messages"]
        assert any(m["role"] == "assistant" for m in msgs), "no assistant turn"
    except Exception as e:
        print(f"line {n}: unusable - {e}")
        bad += 1
        continue
    tokens += sum(len(enc.encode(m.get("content", ""))) for m in msgs)

print(f"{rows} rows, {bad} unusable, {tokens:,} dataset tokens")
print(f"3 epochs = {tokens * 3:,} training tokens = ${tokens * 3 / 1e6 * 0.48:.2f} at $0.48/1M")

line 5: unusable - no assistant turn
line 6: unusable - 'messages'
6 rows, 2 unusable, 53 dataset tokens
3 epochs = 159 training tokens = $0.00 at $0.48/1M

Change the rate and the token count becomes a quote. Take something realistic: 5,000 examples averaging 400 tokens, three epochs, so 6 million training tokens. That is $2.88 on Together's LoRA tier, $2.64 on Tinker, $30 on gpt-4.1-mini, and $150 on full gpt-4.1. Small open models are not where the money goes. Serving them carelessly is.

Two housekeeping steps worth doing before upload, because training data ends up inside checkpoints you may keep for months: scrub it with the PII Redactor, and drop repeats with Remove Duplicate Lines, since near-identical rows both inflate the bill and teach the model to over-weight whatever you pasted twice.

The Step Teams Skip

Reserve 10 to 20 percent of your examples as an evaluation set the training run never sees. Then run one job on default hyperparameters and compare the result against the untuned base model with a good prompt. That single comparison is the only evidence that matters, and it is the one people leave out because it sometimes says the prompt was fine.

If the tuned model wins, ship it and watch cost per request. If it does not, the answer is nearly always more or better examples, not a different vendor.

What I Would Actually Do

Still on OpenAI with tuning in the roadmap: treat 6 January 2027 as immovable and pick a destination now. Foundry disrupts least, Together or Tinker on an open model costs least and outlives the decision.

Chasing the lowest price on something small: Together at $0.48, with Fireworks as your second quote. Below 16B the gap is pennies, so choose on which base models are offered.

Able to score outputs but not write them: that is the RFT case, so Bedrock or SageMaker on AWS, or GRPO in TRL and Unsloth if you want it in-house.

Not certain fine-tuning is even the answer: it probably is not, yet. Better prompt, then retrieval, then distil the working prompt into a smaller model.