AI & LLM Economics

Fine-Tuning Cost Calculator (GPU-Hours vs Managed API)

Enter your training dataset size in millions of tokens, the number of epochs, and how your cluster is set up — GPU type, GPU count, hourly price, and the aggregate training throughput of the whole run. The calculator turns that into wall-clock hours and total GPU-hours, prices the self-managed run at your rental rate, and puts it next to what the same tokens would cost on a managed fine-tuning API priced per training token (Together AI's published SFT rates, as of 2026-07). You get both totals, the difference, and which path is cheaper — for the compute bill of one training run, not the whole project.

The training run

Rough default: a LoRA on an 8B model runs around 3,000 tok/s on 1× H100 — measure your run.

Self-managed cluster

Managed API to compare

Prices as of 2026-07 — verify before committing.

Cheaper path for this run

$11.08

Self-managed GPUs win — saving $3.32 vs the other path

Self-managed

$11.08

Managed API

$14.40

Wall clock

2.78 h

Run detail
Total training tokens30.00 MTokWall-clock hours2.78 hGPU-hours (1× GPU)2.78 hSelf-managed cost$11.08Managed API ($0.48/MTok)$14.40Delta (self − API)−$3.32

Self-managed vs managed API ($)

Self-managed GPUsManaged API

Compute cost of one successful run only — storage, failed experiments, and engineering time are excluded. Throughput defaults are rough: measure your own run.

Compare scenarios

Run the same calculation with two or three input sets side by side. Differences are highlighted; every number comes from the same tested formula as the calculator above.

InputScenario AScenario B
Dataset Tokens M
Epochs
Method
Gpu Id
Gpu Hourly Usd
Gpu Count
Training Tokens Per Sec Aggregate
Api Fine Tune Id

How it works

Total training tokens = dataset tokens × epochs: a 10M-token dataset trained for 3 epochs pushes 30M tokens through the model. Wall-clock hours = total tokens ÷ (aggregate training throughput × 3,600). At 3,000 tokens/second across the cluster, those 30M tokens take about 2.78 hours. Throughput is the honest unknown here — it depends on model size, method, sequence length, precision, and parallelism — so the calculator suggests rough defaults per method and lets you type in the number you actually measured.

Self-managed cost = wall-clock hours × GPU count × price per GPU-hour. The GPU picker prefills on-demand rates from our pricing snapshot (Lambda and RunPod, as of 2026-07) — an H100 SXM at $3.99/h makes the 2.78-hour single-GPU run about $11. The price stays editable, because your negotiated, spot, or reserved rate is what matters. Adding GPUs multiplies GPU-hours, and only shortens wall-clock time if your measured aggregate throughput actually scales with them.

Managed API cost = dataset MTok × epochs × the provider's training price per million tokens: 30 MTok at Together's $0.48/MTok rate for models up to 16B is $14.40, and at the $2.90/MTok 70B-tier rate it would be $87. The delta line shows self minus API — negative means renting GPUs wins on raw compute, positive means the managed API wins before you count any of your own setup time.

Frequently asked questions

Why doesn't choosing LoRA vs full fine-tuning change the result?+

Because the cost math is the same either way: cost = GPU-hours × hourly price, and GPU-hours come from your dataset size and measured throughput. What LoRA changes is the inputs, not the formula — it updates far fewer weights, so it typically trains at higher tokens/second and fits in much less VRAM, meaning fewer or smaller GPUs. That is why the method selector only updates the suggested throughput and GPU-count defaults: pick LoRA, measure your actual run, and the lower hours and smaller cluster show up in the numbers by themselves.

Where do the throughput defaults come from, and can I trust them?+

They are rough, order-of-magnitude starting points — for example ~3,000 tokens/second for an 8B LoRA on one H100, or ~800 tokens/second aggregate for a full 70B fine-tune on 8× H100 — not benchmarks of your workload. Real training throughput moves by multiples with sequence length, batch size, precision (bf16 vs fp8), gradient checkpointing, and how well tensor or data parallelism scales on your interconnect. Run a short timed job on a slice of your data, divide tokens processed by seconds elapsed, and enter that. GPU prices are snapshot rates as of 2026-07 — verify current pricing before committing.

What costs does this calculator leave out?+

Everything except the compute bill of one successful training run. On the self-managed side it excludes storage and data transfer, cluster setup and babysitting time, failed and repeated runs, hyperparameter sweeps (each sweep is another full run — multiply accordingly), and the engineering hours that often dwarf an $11 GPU bill. On both sides it excludes data preparation and the cost of serving the fine-tuned model afterwards, which usually exceeds training cost over the model's life. Treat the output as the floor of one experiment, not the budget for a fine-tuning project. This is an estimate, not financial advice.

Related tools

Sources

Embed this calculator

+

Drop this calculator into your own site — free. Keep the credit link below the frame: it’s how the free embed stays free.