Best AI Fine-Tuning Platforms in 2026: Hosted and Open Source Compared

The most important fact about fine-tuning in 2026 is on OpenAI's deprecations page, dated 7 May 2026. Organizations that have never run a fine-tuning job can no longer create one. Since 2 July 2026, new jobs are limited to organizations that ran inference on a fine-tuned model in the last 60 days. On 6 January 2027, even those customers lose the ability to create new jobs, and fine-tuned versions of gpt-3.5-turbo, gpt-4, gpt-4.1-nano, babbage-002 and davinci-002 shut down on 23 October 2026.

Meanwhile everything around it opened up. AWS put reinforcement fine-tuning on open-weight models, Microsoft made training global across 13 regions, and per-token training on an 8B model fell under a dollar per million tokens. Every price below came from the provider's own pricing page, and both code samples were run locally before publishing.

When It Is the Right Tool

Fine-tuning teaches behavior, not facts. If the model does not know about your internal API you want retrieval, and our RAG platforms guide covers that. If it knows what to do but formats it wrong, ignores your tone or picks the wrong label, fine-tuning fixes that in a way prompt text does not. The practical test: can you write 200 to 1,000 examples of the behavior you want? If not, no platform here helps.

Four methods matter. SFT trains on input and ideal-output pairs and is what most teams need. DPO trains on preferred versus rejected pairs, for when quality is taste rather than correctness. RFT, usually GRPO, trains against a grader that scores outputs, which fits tasks you can score but cannot hand-write answers for. Distillation trains a small model on a large one's outputs to cut inference cost.

Cutting across all four is LoRA, which trains a small adapter and freezes the base. From a run on my laptop with peft 0.20.0:

Python
Copy
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()

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

Training 1.35 percent of the parameters is why LoRA is cheap, and a 3.5 MiB adapter against a 260 MiB model is why dozens of task variants fit on one GPU.

The Clouds

The guide itself now carries a notice that its fine-tuning workflows are "being moved into legacy documentation", which is the same message from a second direction. OpenAI still works for existing customers: SFT and DPO on gpt-4.1, mini and nano, vision on gpt-4o-2024-08-06, RFT only on o4-mini-2025-04-16. Training runs $25 per million tokens for gpt-4.1, $5 for mini, $1.50 for nano; RFT is $100 per hour of core training time. No GPT-5 model was ever tunable, and the retirement notes point users at untuned gpt-5.4-mini and gpt-5.5 instead. Read together, OpenAI would rather you prompt and retrieve than train.

Microsoft Foundry expanded what OpenAI retired. RFT on o4-mini supports Global Training across 13 regions at lower per-token rates than standard training, trading away data residency. GPT-4.1, mini and nano work as model graders, and Microsoft suggests starting with nano. If you want managed OpenAI-family tuning that is not scheduled for shutdown, this is the closest drop-in.

Google Vertex bills training tokens as dataset tokens times epochs, then charges more per token to serve the tuned endpoint than the base model, which catches teams out. Check availability rather than assuming: Google rotates tunable snapshots as models retire, and Gemini 3.x tuning has arrived by preview and allowlist rather than self-serve.

AWS treats open weights as first-class. Bedrock added RFT for Qwen3-32B and gpt-oss-20b on 17 February 2026, callable straight away through its OpenAI-compatible Responses and Chat Completions APIs. SageMaker AI went wider on 25 March 2026 with serverless SFT, DPO and RFT for twelve more open models including gpt-oss-120b and Qwen3 14B, in N. Virginia, Oregon, Tokyo and Ireland. Anthropic is the absence: no fine-tuning in the public Claude API, customization only via Bedrock on whichever Claude models it exposes, historically Haiku.

The Specialists

Together AI does LoRA and full fine-tuning plus SFT and DPO. LoRA supervised tuning is $0.48 per million training tokens up to 16B, $1.50 for 17B to 69B, $2.90 for 70B to 100B. That $0.48 is the number to benchmark against. Fireworks AI is $0.50 up to 16B, then $3.00 to 80B and $6.00 to 300B, so competitive small and roughly double at mid-size.

Predibase prices GRPO at $10 per million tokens up to 16B and $20 for 16.1B to 32B, with serverless inference free to 1 million tokens a day. One caveat: it has been part of Rubrik since June 2025, and as of August 2026 predibase.com no longer serves its own site, redirecting to Rubrik Agent Cloud. Confirm it is still sold standalone before committing.

Tinker is my pick for control without operating GPUs. It bills per million tokens, not GPU-hours: Qwen3-8B went from $0.40 to $0.44 per million on 17 July 2026, so a 50 million token run costs about $22, plus $0.10 per GB-month for checkpoints. LoRA only at default rank 32, exporting a standard PEFT adapter, so nothing traps you.

The Open Source Stack

Unsloth (2026.8.3) is the throughput play: GRPO about 1.3x faster, mixture-of-experts training 3 to 5x faster, and up to 80 percent less VRAM for reinforcement learning, which is what makes GRPO viable on consumer cards. Axolotl (0.18.0) is the YAML workhorse, so runs are reviewable in a pull request rather than trapped in a notebook. LLaMA-Factory (0.9.5) claims the widest surface at over 100 LLMs and ships a web UI. TRL (1.9.2) with PEFT (0.20.0) is the library layer under all of it, now shipping SFT, DPO and GRPO trainers directly.

The catch is that you own the GPU, CUDA and evaluation problems. Rule of thumb: pay a hosted platform to learn whether the approach works, then move to the open stack once you run the job weekly.

Validate the Data Before You Pay

Providers bill on training tokens, so a malformed dataset costs money before it costs you an evaluation. This checks the chat JSONL format the major platforms expect and prices the run. Against a deliberately broken six-row file:

Python
Copy
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")

text
Copy
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

Swap the rate for your provider and the token count becomes a budget. A realistic 5,000 examples at 400 tokens over three epochs is 6 million training tokens: $2.88 on Together's LoRA tier, $2.64 on Tinker, $30 on gpt-4.1-mini, $150 on full gpt-4.1.

How to Run Your First Fine-Tune

1. Write 200 examples by hand in the exact format you want back. This is the whole project; inconsistent examples teach inconsistency faithfully.
2. Strip anything sensitive before it leaves your machine with our PII Redactor, since training data lands in checkpoints you may keep for months.
3. Deduplicate. Near-identical rows inflate the bill and skew the model. Remove Duplicate Lines handles exact matches, the Text Similarity Calculator catches near-misses.
4. Validate and cost it with the script above, holding back 10 to 20 percent as an evaluation set the training run never sees.
5. Run one job on default hyperparameters, then compare it against the untuned base model with a good prompt. That comparison is the only one that matters and it is the step teams skip. Our LLM evals guide covers doing it properly.

Comparison

How to Pick

On OpenAI with fine-tuning in the plan: treat 6 January 2027 as a hard date. Foundry is least disruptive; Together or Tinker on an open model is cheaper and more durable.

Lowest price on a small model: Together at $0.48 per million, with Fireworks as the comparison quote. Under 16B the difference is pennies, so pick on model availability.

You can score outputs but not write answers: that is the RFT case. Predibase, Bedrock or SageMaker if you are on AWS, or GRPO in TRL and Unsloth if you would rather own it.

Control without running GPUs: Tinker, because per-token billing and exportable adapters mean you can leave.

Not sure fine-tuning is the answer: it probably is not yet. Try a better prompt, then retrieval, then distillation.

Conclusion

Fine-tuning is now an open-weights activity with hosted convenience on top, not a frontier-model feature you rent. Write 200 clean examples, validate them with the script above, run one cheap job on Together or Tinker, and compare honestly against a well-prompted base model before spending on infrastructure.

Related DevToolLab Tools

• PII Redactor - Strip emails, keys and account numbers from a training set before it leaves your machine.
• NDJSON to JSON Converter - Inspect or reshape the JSONL files every fine-tuning API expects.
• Remove Duplicate Lines - Drop repeated rows that inflate your token bill.
• Text Similarity Calculator - Find near-duplicates that exact deduplication misses.

Related Guides

• Best RAG Platforms and Tools - the alternative when the problem is missing knowledge, not wrong behavior
• LLM Evals Guide - proving a tuned model beats a well-prompted base model
• Best LLM Gateways - routing and cost control across several tuned variants
• Best Local LLM Tools and Models - running the open weights you just fine-tuned

Prices and model availability change monthly. Verify current rates with each provider before committing.