Loading the Elevenlabs Text to Speech AudioNative Player...

Fine-tuning used to mean a cluster, a contract and a week of setup. In 2026 most teams adapt an open model such as Llama, Qwen or Mistral to their own data with LoRA, a method that trains a small set of extra weights instead of the whole model. A LoRA run on a mid-size model is a job measured in minutes to hours, not weeks, so the question has changed from "can we afford a GPU cluster?" to "what does one hour of the right GPU cost, and how fast can I get it?"

This piece answers that with live numbers from Lium, a GPU marketplace where independent providers list NVIDIA machines and renters pay by the second.

What one hour costs (prices read 20 October 2026, 21:44 UTC)

Lium publishes its prices as a public feed, so these are the cheapest machines that were actually available to rent at the time of writing, not list prices:

GPU

Memory per GPU

Lowest available price per GPU-hour

L40S

48 GB

$0.38

RTX A6000

48 GB

$0.42

RTX 4090

24 GB

$0.55 (spot tier)

RTX 5090

32 GB

$0.90

A100 80GB (8-GPU node)

80 GB

$1.68

H100 80GB (8-GPU node)

80 GB

$1.80 (spot tier)

H200 (single GPU)

141 GB

$3.50

B200

180 GB

$5.00

Prices on a marketplace move with supply, so check the feed on the day you rent. At the time of writing the fleet had 1,835 GPUs listed, of which 229 were free to rent.

What that means for a fine-tune:

  • A small LoRA run on a single 48 GB card (L40S or RTX A6000) costs under $0.50 for a full hour.
  • A bigger model on one H200 with 141 GB of memory, enough to skip multi-GPU setup for many jobs, costs $3.50 for the hour.
  • A full 8x H100 node for a heavier run costs $14.40 for the hour at the spot price above.

Why per-second billing matters for fine-tuning

Fine-tuning is bursty. You run a short test to check the data loads, fix a bug, run again, then do the real run. On a cloud that bills by the hour, every false start costs a full hour.

Lium bills per second at the hourly price, with no minimum. The formula in its billing docs is simply hourly price x seconds / 3600. A 10-minute smoke test on a $0.42 RTX A6000 costs about 7 cents. Charging stops at the moment you delete the pod, and a pod that fails to start is not charged.

How fast you get a machine

Waiting is also a cost. On 20 October we timed renting a full 8x H100 node on Lium from the click on "Deploy" in the web page to a working root shell: 12.3 seconds. An 8x B300 node took 14.8 seconds. Both runs were screen-recorded end to end.

That speed changes how you work. You can rent the GPU when the data is ready, not hours ahead "just in case", and release it the moment training ends.

The main steps

1. Pick a GPU that fits your model

Rule of thumb: LoRA on a 7-8B model fits on one 24-48 GB card; a 70B model needs an H200 or several 80 GB GPUs. Filter by GPU and price in the Lium web app, or from the terminal:

pip install lium.io
lium ls --gpu H100 --count 8 --max-price 2.50

2. Rent it with a time limit

lium up <node-id> --ttl 1h --name finetune

The --ttl flag tells the platform to remove the pod after one hour even if you forget, so a forgotten machine cannot run up a bill.

3. Copy your data and train

Copy your dataset with lium scp or lium rsync, then run your usual training script (Hugging Face TRL, Axolotl or Unsloth all work on a standard PyTorch template) with lium exec finetune "python train.py".

4. Save the adapter and delete the pod

Copy the LoRA adapter back, then run lium rm finetune. Billing stops at the delete request.

Let an agent do it

Many developers now hand the whole loop to a coding agent. Lium runs an MCP server that lets Claude Code and Codex find GPUs with live prices and rent and remove pods with your API key. You can ask the agent to "find the cheapest 48 GB GPU, fine-tune this model on data.jsonl for one epoch and bring back the adapter", and it works through the same steps above. The time limit on the pod is a good safety net when an agent is driving.

The bottom line

In 2026 the cost of fine-tuning an open model is set less by the GPU price and more by the waste around it: hours billed for minutes used, machines left running, and time spent waiting for capacity. Pay-per-second billing, a 12-second deploy and a hard time limit on each pod remove most of that waste. A first LoRA experiment on a 48 GB card costs less than a coffee.

You can see live GPU prices and rent one at Lium.