# OpenAI fine-tuning vs open models: which costs less?

> Fine-tuning an open model on hourly GPUs costs a few percent of OpenAI's per-token training price. Worked math, serving break-even and OpenAI shutdown dates.

Source: https://www.nodus-compute.ai/blog/openai-fine-tuning-vs-open-models/
Build revision: ab28964f886ac7fbf307953c08e7a9b550f2eb1f

<!-- vale Nodus.Providers = NO -->

Fine-tuning an open model costs far less: 50 million training tokens cost about $8 as a Llama 3.1 8B LoRA run on one H100 on Nodus, against $250 on OpenAI’s gpt-4.1-mini and $1,250 on gpt-4.1. Serving is closer, because a dedicated GPU bills by the hour whether or not traffic arrives, so open models win there only above a monthly token volume you can calculate. OpenAI is also winding down self-serve fine-tuning, which settles the choice for most teams.

## How does OpenAI price fine-tuning?

OpenAI bills training per token, then bills the fine-tuned model per token when you call it. Training is charged on every token in your dataset, once per epoch. The [data-prep cookbook](https://developers.openai.com/cookbook/examples/chat_finetuning_data_prep) states it as “you’ll be charged for \~n_epochs x tokens in dataset”. People searching for “ChatGPT fine-tuning cost” usually mean this API product.

|Model|Training per 1M tokens|Input per 1M|Cached input per 1M|Output per 1M|
|-|-|-|-|-|
|gpt-4.1-2025-04-14|$25.00|$3.00|$0.75|$12.00|
|gpt-4.1-mini-2025-04-14|$5.00|$0.80|$0.20|$3.20|

Prices checked November 15, 2026 on [OpenAI’s pricing page](https://platform.openai.com/docs/pricing), standard tier. The Batch tier halves input and output prices on fine-tuned models but keeps the same training price.

## Can you still fine-tune on OpenAI?

Only if your organization already was. OpenAI’s [deprecations page](https://developers.openai.com/api/docs/deprecations#update-to-openais-self-serve-fine-tuning) lists the timeline:

* May 7, 2026: organizations that had never run fine-tuning can no longer create jobs.
* July 2, 2026: organizations with no fine-tuned model inference in the past 60 days lose job creation.
* January 6, 2027: active existing customers can no longer create new fine-tuning jobs.

Inference keeps working until the base model shuts down. The [supervised fine-tuning guide](https://developers.openai.com/api/docs/guides/supervised-fine-tuning) says gpt-4.1, gpt-4.1-mini and their fine-tuned versions shut down on January 14, 2027. That date matters more than any price. A fine-tuned OpenAI model is a rented artifact with an end date, while a LoRA adapter you train on an open model is a file you keep.

## What does the same dataset cost on each side?

We priced one dataset four ways. It is 25 million tokens of examples trained for 2 epochs, so 50 million training tokens. That is the worked example from our [Llama on H100 cost post](https://www.nodus-compute.ai/blog/cheapest-way-to-fine-tune-llama-on-h100/), which used a published torchtune throughput as a stand-in rather than a run we measured.

The arithmetic, once:

* OpenAI gpt-4.1-mini: 50 x $5.00 = $250.00.
* OpenAI gpt-4.1: 50 x $25.00 = $1,250.00.
* Llama 3.1 8B LoRA on 1 x H100 on Nodus: 50,000,000 / 4,699 tokens per second = 2.96 hours, plus 15 minutes of startup, at $2.60/hr = $8.35.
* Llama 3.3 70B LoRA on 1 x B200 on Nodus: our [70B fine-tuning cost post](https://www.nodus-compute.ai/blog/fine-tune-70b-model-cost/) estimates $19.16 of training for 20 million tokens. Scaled to 50 million that is $19.16 x 2.5 = $47.90, plus 15 minutes at $5.50/hr ($1.375), so $49.28.

![Training cost for 50 million training tokens: OpenAI gpt-4.1 $1,250.00, OpenAI gpt-4.1-mini $250.00, Llama 3.3 70B LoRA on one B200 on Nodus $49.28 and Llama 3.1 8B LoRA on one H100 on Nodus $8.35.](https://www.nodus-compute.ai/blog-charts/openai-fine-tuning-vs-open-models/training-cost.svg) *At list prices, a 70B open model fine-tunes for about a twenty-fifth of what gpt-4.1 charges for the same tokens.*

Treat the Nodus rows as planning numbers. The 8B row rests on a throughput from different hardware and the 70B row on FLOP math at 30% utilization. Neither one compares model quality: an 8B Llama is not a drop-in for gpt-4.1-mini on every task. What the gap shows is scale.

Even if your real throughput were five times worse, the open-model rows would still cost a fraction of the OpenAI ones. Nodus rates are listed on the [Nodus pricing page](https://www.nodus-compute.ai/pricing/), checked November 15, 2026.

## How fast does a GPU have to train to beat per-token pricing?

Very slowly. Divide the hourly rate by the per-token price and you get the training speed at which the two cost the same:

|Comparison|Break-even training speed|
|-|-|
|H100 at $2.60/hr vs gpt-4.1-mini at $5.00 per 1M|520,000 tokens/hr, about 144 tokens/s|
|H100 at $2.60/hr vs gpt-4.1 at $25.00 per 1M|104,000 tokens/hr, about 29 tokens/s|
|B200 at $5.50/hr vs gpt-4.1 at $25.00 per 1M|220,000 tokens/hr, about 61 tokens/s|

For comparison, the torchtune figure behind our 8B example is 4,699 tokens per second. A LoRA run that trains slower than 144 tokens per second on an H100 has a setup problem worth fixing, not a pricing problem. Our [best fine-tuning platform guide](https://www.nodus-compute.ai/blog/best-platform-to-fine-tune-open-source-llms/) runs the same division against cheaper per-token LoRA prices, where the bar is much higher.

## When is serving your own fine-tuned model cheaper?

Serving is where per-token pricing can win, because a GPU you keep up costs the same at 3 a.m. as at noon. Assume the 3 input tokens per output token that Nodus uses as its reference mix in the [inference guide](https://www.nodus-compute.ai/docs/guides/inference/). The blended price per 1M tokens is then:

* Fine-tuned gpt-4.1-mini: (3 x $0.80 + $3.20) / 4 = $1.40.
* Fine-tuned gpt-4.1: (3 x $3.00 + $12.00) / 4 = $5.25.

One NVIDIA L40S, listed at $0.793/hr on the Nodus pricing page, costs $0.793 x 720 hours = $570.96 a month. A 48 GB card holds an 8B model’s 16 GB of 16-bit weights with room for the KV cache. The break-even volume is the monthly GPU cost divided by the blended price:

|Serving GPU, 720 hours|Monthly cost|Break-even vs ft gpt-4.1-mini|Break-even vs ft gpt-4.1|
|-|-|-|-|
|L40S at $0.793/hr|$570.96|408M tokens/month (157 tokens/s)|109M tokens/month (42 tokens/s)|
|H100 at $2.60/hr|$1,872.00|1,337M tokens/month (516 tokens/s)|357M tokens/month (138 tokens/s)|

![Monthly serving cost from 0 to 600 million tokens: fine-tuned gpt-4.1 rises to $3,150, fine-tuned gpt-4.1-mini rises to $840, and one L40S on Nodus stays flat at $570.96.](https://www.nodus-compute.ai/blog-charts/openai-fine-tuning-vs-open-models/serving-breakeven.svg) *Against fine-tuned gpt-4.1, one L40S pays for itself at about 109M tokens a month.*

At 600M tokens a month, fine-tuned gpt-4.1-mini costs $840 and fine-tuned gpt-4.1 costs $3,150, against $570.96 for the L40S. The tokens-per-second column is the average your GPU must sustain around the clock, so measure your own serving throughput at your real prompt lengths before you commit. Serving several adapters on one GPU moves the line further: vLLM [serves LoRA adapters per request](https://docs.vllm.ai/en/latest/features/lora.html) on top of one base model.

## Where is OpenAI fine-tuning the better choice?

There are honest cases, mostly for teams that already have it.

* You already run a fine-tuned gpt-4.1 or gpt-4.1-mini that passes your evals, and your volume is below the break-even above. Keep it until you have a replacement ready, and plan for the January 14, 2027 shutdown.
* Your dataset is tiny. OpenAI’s guide reports improvements from 50 to 100 examples. At 50 examples of 1,000 tokens for 3 epochs, training is 150,000 tokens, or $0.75 on gpt-4.1-mini. At that size the cost difference is cents and the deciding factor is engineering time.
* Your traffic is low and spiky. Per-token serving bills nothing when nobody calls the model; a dedicated GPU bills every hour it is up.
* Your task needs the base model’s quality and no open model you tested matches it on your held-out set. A cheaper model that fails your evals is not cheaper.

For new projects the first case no longer applies, and the last two are reasons to compare serving options, not reasons to wait for a platform that is closing.

## How do you run the open-model version on Nodus?

Nodus runs fine-tuning as a TrainingJob on the managed `nodus/sft` runtime, which supports full fine-tuning, LoRA and QLoRA. This is the LoRA example from the [training guide](https://www.nodus-compute.ai/docs/guides/training/), copied as published. Swap in your model and data:

```yaml
apiVersion: nodus.dev/v1beta1
kind: TrainingJob
metadata:
  name: support-sft
spec:
  runtime: nodus/sft
  model:
    uri: hf://Qwen/Qwen3-0.6B@c1899de289a04d12100db370d81485cdf75e47ca
    secret: hf-token            # only for gated repositories
  data:
    volume: support-chats       # a Volume holding chats.jsonl
    path: chats.jsonl
    format: JSONL
    columns: {prompt: question, completion: answer}
  parameters:
    steps: 2000
    lora: {r: 16, alpha: 32}
  maxCostUSD: "20.00"
```

Price it before anything runs, then start it:

Terminal window

```console
$ nodus apply -f sft.yaml --dry-run -o yaml     # status.estimate: cost to completion, first hold, start time
$ nodus apply -f sft.yaml
```

`maxCostUSD` caps the whole job and suspends it at a checkpoint rather than failing it. While it trains, `nodus describe` shows tokens per second, which is the number to plug into the break-even tables above. The adapter lands under `outputs/adapter/`, and you download it with `nodus cp`, per the [sft runtime reference](https://www.nodus-compute.ai/docs/reference/runtimes/sft/). TrainingJobs are Beta, so read the dry run before the real run.

A practical decision rule from the numbers above:

1. New project, or an OpenAI fine-tune you would need to retrain after January 6, 2027: fine-tune an open model.
2. Existing OpenAI fine-tune: compare its monthly tokens with the serving break-even. Above it, move now; below it, move before the shutdown, and look at per-token open-model serving.
3. Either way, export the training data you used with OpenAI. It is the one asset that carries over unchanged.

## FAQ

### How much does fine-tuning gpt-4.1-mini cost for 1,000 examples?

Multiply the tokens by the epochs. At 1,000 examples of 1,000 tokens and 3 epochs, that is 3 million training tokens, or $15 at $5.00 per 1M. The same run costs $75 on gpt-4.1.

### Do more epochs raise the OpenAI bill?

Yes, linearly, because every epoch re-bills the whole dataset. OpenAI’s cookbook estimate starts from 3 epochs and adjusts for very small or very large datasets, so check the epoch count before you launch.

### Is a fine-tuned open model as good as a fine-tuned GPT model?

Sometimes, and only your held-out evals can say. Nodus can validate during training and fail a job that does not beat the starting model’s validation loss. Still, the training guide says a separate untouched test set must establish task quality.

### Can I keep using my fine-tuned OpenAI model after January 6, 2027?

Yes, for inference, until its base model shuts down. For gpt-4.1 and gpt-4.1-mini that is January 14, 2027, so the window after the training cutoff is eight days.

### Is it cheaper to self-host than to pay per token for an open model?

Only above the break-even volume for your GPU. Below it, a per-token hosted endpoint is usually cheaper, and the Nodus [inference API](https://www.nodus-compute.ai/docs/guides/inference/) serves open-weight catalog models per token.
