The fine-tuning cost calculator above answers the two questions that decide whether a custom model is worth building: what the training run costs, and how many requests it takes before the change pays for itself. Training cost is the easy half and the half everyone estimates. The half that determines the outcome is the per-request difference between running the base model and running the tuned one, which frequently points the wrong way.
Arb Digital runs this comparison before recommending fine-tuning to a client, because the intuitive assumption — that a smaller specialised model must be cheaper — depends entirely on whether the prompt gets shorter. This page shows how to model that properly, using your provider's current rates rather than numbers copied from a blog post.
What This Fine-Tuning Cost Calculator Does
Enter your dataset size, average example length, epoch count, and training rate to get the training cost as the headline number. Then enter the input and output rates for both the base model and the tuned model, your typical request shape, and how many prompt tokens the tuning lets you delete. The tool returns the cost per thousand requests on each model, the monthly difference at your volume, and — in the subheading under the headline figure — the number of requests at which the training cost is recovered.
If the tuned model is more expensive per request and the prompt does not shrink enough to compensate, the tool says so explicitly rather than printing a break-even number that will never arrive. That is the most useful output it produces.
How to Use It
- Enter your training examples and their average length. Count the full example — prompt and completion together, including any system message that appears in each training record.
- Set epochs. Every epoch is another complete pass over the dataset, and every pass is billed. Providers often select this automatically based on dataset size.
- Enter training and inference rates. Replace all five price defaults with current published figures for the specific model you intend to tune.
- Describe a typical request. Input tokens should reflect the prompt after tuning; put whatever you expect to remove into the separate field below it.
- Set the prompt tokens removed by tuning and your monthly volume, then click Calculate to see break-even and the monthly difference together.
The Formula / How It's Calculated
Training cost is examples × tokens per example × epochs × training rate ÷ 1,000,000. Five thousand examples of 600 tokens over three epochs is nine million tokens processed, and the bill scales linearly with all three inputs. Nothing subtle happens here — the subtlety is all on the inference side.
Base cost per request is (request input + removed tokens) × base input rate + output × base output rate, because on the base model you are still sending the few-shot examples and long instructions. Tuned cost per request is request input × tuned input rate + output × tuned output rate. The saving per request is the difference, and break-even volume is training cost ÷ saving per request. When the saving is zero or negative, there is no break-even at any volume.
Fine-Tuning Saves Prompt Length, Not Token Price
Hosted fine-tuned models are typically priced above their base equivalents, because your weights need dedicated serving capacity. So on identical prompts, the tuned model is the more expensive option — every request, forever. The economics only work when the tuning lets you delete something from the prompt.
That deletion is usually few-shot examples. A prompt carrying eight demonstrations of the desired output format can run to several hundred tokens that are re-sent on every single request, purely to teach a behaviour. Fine-tuning moves that behaviour into the weights, and those tokens disappear. Set the removed-tokens field to zero and watch the break-even disappear with it. That single experiment is the fastest way to understand whether your use case is a candidate at all.
Epochs Multiply Everything
Epoch count is the input teams pay least attention to and it scales the training bill directly. Three epochs cost three times one epoch, and if your dataset grows tenfold, the two multiply. More passes are not automatically better either: past a point the model begins fitting the specifics of your training examples rather than the pattern behind them, which shows up as confident, fluent, wrong answers on inputs that differ slightly from the training distribution.
Providers document their defaults and let you override them — OpenAI's fine-tuning guide explains how epochs and other hyperparameters are chosen, and Google's model tuning documentation covers the equivalent for Gemini. Treat any deviation from the default as an experiment with a cost attached, which this calculator will quantify before you launch the job.
The Costs That Never Appear on the Invoice
The training charge is often the smallest part of a fine-tuning project. Dataset construction dominates: producing several thousand high-quality, consistently formatted examples takes real human hours, and quality matters more than volume — a thousand carefully reviewed examples generally beat ten thousand noisy ones.
Then there is evaluation. A tuned model has to be measured against the base model on a held-out set before it can be trusted in production, and that evaluation costs inference tokens on both models plus review time. Budget for at least two or three training runs, because the first configuration is rarely the one you ship. Multiply the headline training figure by the number of runs you realistically expect, and add the evaluation inference on top, before comparing it to the monthly saving.
Retraining Cadence Changes the Break-Even
A break-even calculated once assumes the tuned model stays useful indefinitely. In practice, models are retrained when the product changes, when the output format changes, or when the base model you tuned from is deprecated and you have to move to a newer one — which means training again from scratch on the new base.
The honest way to read the break-even number is against your retraining interval, not against eternity. If break-even arrives at 400,000 requests and you serve 100,000 a month, you recover the cost in four months. If you expect to retrain every quarter, you never quite get there. Divide your monthly volume into the break-even figure and compare the result with how long you realistically expect this version to live.
When Prompting or Retrieval Is the Better Tool
Fine-tuning teaches behaviour: format, tone, structure, a consistent style of judgement. It is a poor way to teach facts, because facts change and weights do not, and because a model asked to recall a specific detail from training data will sometimes produce something adjacent and plausible instead. Knowledge that changes belongs in retrieval, where it can be updated by editing a document — the RAG chunk size calculator and the embedding cost calculator cover the cost side of that approach.
Before committing, try the cheaper interventions in order: a clearer prompt, a smaller base model with good instructions, prompt caching to reduce the cost of long few-shot blocks, then fine-tuning. Caching in particular competes directly with the main financial argument for tuning, since it reduces the cost of exactly those repeated instruction tokens — model that first in the prompt cost optimizer. If a smaller model with a good prompt reaches acceptable quality, compare rates in the LLM cost comparison tool and stop there.
Arb Digital evaluates all three against your actual traffic and quality bar, so the choice is made on measured cost rather than assumption.
Browse Free Tools Talk to Arb DigitalCommon Mistakes to Avoid
- Assuming a tuned model is cheaper per token — hosted fine-tuned models are usually priced above their base equivalents, so the saving has to come from a shorter prompt.
- Budgeting for one training run — most projects need several before the configuration is right, and each one is billed in full.
- Counting only prompt tokens in the dataset — training bills the completion side as well, so a record's full length is what matters.
- Fine-tuning to inject facts — knowledge that changes belongs in a retrieval layer where it can be edited without retraining.
- Ignoring dataset preparation effort — the human time to build and review examples routinely exceeds the compute charge by a wide margin.
Related Free Tools From Arb Digital
Size your training records with the AI token calculator, compare candidate base models in the AI model comparison tool, price ordinary inference with the GPT API cost calculator, test prompt trimming in the prompt cost optimizer, and sanity-check the overall case with the AI ROI calculator. More in the free online tools hub.
Frequently Asked Questions
Usually not per token. Hosted fine-tuned models generally carry higher input and output rates than their base equivalents. The saving comes from being able to send a much shorter prompt, so it depends on how many instruction and example tokens the tuning removes.
By tokens processed, which is dataset size multiplied by tokens per example multiplied by epochs. Every epoch passes the entire dataset again, so epoch count scales the bill directly.
Providers commonly suggest starting in the low hundreds for behavioural tasks and measuring improvement before scaling up. Consistency and quality of examples matter more than raw volume, and a small clean dataset often outperforms a large noisy one.
It is the training cost divided by the per-request saving. If the tuned model does not cost less per request than the base model with its full prompt, there is no break-even at any volume, however large.
Generally no. Fine-tuning is well suited to teaching format, tone, and consistent behaviour. Facts that change are better held in a retrieval layer, where updating a document is instant and does not require retraining.
It addresses the same cost problem from another direction by reducing what repeated instruction tokens cost. If long few-shot blocks were your main reason for tuning, model caching first, since it requires no training run.
Whenever your output requirements change or the base model you tuned from is retired. Compare your break-even volume against how long you expect this version to remain in service rather than assuming it runs indefinitely.
Figures produced by this tool are planning estimates only — actual costs depend on your provider's current training and serving rates, hyperparameter choices, and the number of runs your project needs.
