Nodus is the better fit for single-machine training runs of hours or days that you want to submit and stop watching. Its listed NVIDIA H100 rate is below Nebius AI Cloud's on-demand rate, and a run that loses its machine resumes from its last checkpoint on a new one. Nebius is the better fit for large InfiniBand clusters reserved for months, for managed Kubernetes or Slurm, and for teams that run on its preemptible VMs and handle restarts themselves.
One disclosure before the numbers: we build Nodus. Every Nebius fact below links to Nebius's own pricing page or docs, and the arithmetic is written out so you can redo it with your own rates.
Which is cheaper for one day on 8 x H100?
At listed on-demand rates, the same day of training costs about 42% less on Nodus. We priced one job, a fine-tune on one 8 x NVIDIA H100 machine for 24 hours, from each company's public pricing page. That is 8 x 24 = 192 GPU-hours.
| Where it runs | Listed H100 rate | 192 GPU-hours |
|---|---|---|
| Nebius on-demand | $4.50/hr | $864.00 |
| Nebius preemptible, at its listed floor | from $0.79/hr | from $151.68 |
| Nodus | $2.60/hr | $499.20 |
Prices checked October 25, 2026: Nebius AI Cloud pricing and the hourly rates on the Nodus pricing page. Nebius's GPU-hour price includes the vCPUs and RAM listed beside it (16 vCPUs and 200 GB per H100). Storage is extra on Nebius, for example its shared filesystem at $0.08/GiB/month.
Against Nebius on-demand, the run costs $364.80 less on Nodus. The gap holds on bigger cards too: Nebius lists the H200 at $5.40, the B200 at $8.50 and the B300 at $9.50 per GPU-hour on demand, against $3.593, $5.50 and $6.943 on Nodus.
On every card from H100 to B300, the listed Nodus rate is below Nebius on-demand.
The preemptible row needs care. Nebius says spot prices move with capacity and demand, can change as often as every 15 minutes, and top out one cent below the on-demand rate (pricing notes). So the same 192 GPU-hours could cost anything from $151.68 to $862.08 (192 x $4.49). If you can live with interruptions and the price is near its floor when you run, Nebius preemptible is the cheapest option in this table.
Nodus costs 42% less than Nebius on-demand for the same day; only Nebius preemptible near its floor costs less.
Nebius also offers commitment discounts for long, stable workloads. They require a company account, are arranged with Nebius sales and are generally prepaid (commitment discounts), so there is no public rate to put in the table.
On Nodus, nodus run --dry-run prints the expected cost of your exact run before anything starts.
How do Nodus and Nebius compare at a glance?
The basic difference is what you are handed. Nebius gives you infrastructure: virtual machines, GPU clusters, Kubernetes and Slurm that your team builds its training setup on. Nodus takes a run (a Job, TrainingJob, Function or Workspace), picks the machine, checkpoints it and replaces it if it is lost.
| Nebius AI Cloud | Nodus | |
|---|---|---|
| What you launch | VMs (on-demand or preemptible), InfiniBand GPU clusters, Managed Kubernetes, Managed Soperator (Slurm) | A run that Nodus places on the cheapest capacity that fits your limits |
| Pricing model | Pay-as-you-go per GPU-hour; preemptible VMs at a dynamic spot price; commitment discounts through sales | Prepaid credits; a funded hold is placed before work starts and renewed every 5 minutes |
| GPUs on the pricing page | L40S to B300, plus GB200 and GB300 NVL72 on request | RTX 3070 to B300 |
| Interrupted machine | Preemptible VM gets SIGTERM 60 seconds ahead, then stops; volumes are kept; it does not restart itself | Urgent checkpoint, replacement prepared at once, run resumes from your state directory |
| Multi-node | GPU clusters on InfiniBand, 400 Gbps per GPU, 3.2 Tbps per 8-GPU node | Beta: 2 to 8 nodes |
| Hosted inference | Token Factory, an OpenAI-compatible API for open models | Beta: OpenAI-compatible API |
| Getting started | $25 minimum first payment | $2 credit after verification, $28 more after the first paid top-up, valid 30 days |
Sources: Nebius pricing, preemptible VMs, InfiniBand GPU clusters, Managed Kubernetes, Slurm and Soperator, Token Factory, the Nodus pricing page, Nodus recovery docs and Nodus credits. Prices checked October 25, 2026.
What happens to a training run when a Nebius preemptible VM is reclaimed?
The VM stops and waits for you. Nebius sends SIGTERM 60 seconds before stopping a preemptible VM, keeps the data on its attached volumes, and drops dynamic resources such as a dynamic public IP (preemptible VMs). Preemptible VMs only support the FAIL recovery policy, so the VM is stopped rather than restarted, and the only on_preemption value is STOP.
That leaves the restart with you: something has to notice, start the VM again or create a new one, and launch training from the last checkpoint.
On-demand Nebius VMs are different: they accept a RECOVER policy that tries to restart the VM after a failure (managing VMs). And if you run on Managed Kubernetes or Soperator, Nebius replaces unhealthy nodes for you (Kubernetes node recovery, Soperator health checks). Your job setup decides how training resumes from its checkpoint on the new node.
On Nodus the restart is the platform's job. On a reclaim notice, Nodus asks your program for an urgent checkpoint and prepares a replacement machine at the same time. A machine that goes silent gets a replacement prepared after 20 seconds and on shared capacity is declared lost after 60 seconds. The new attempt starts with your state directory restored, and an attempt that comes back late can never overwrite its successor (attempts and recovery).
Here is what that means for the 24-hour job if its machine is lost at hour 20 with a checkpoint saved at hour 19.5. Both platforms redo the same half hour: 0.5 x 8 x $2.60 = $10.40 on Nodus, and 0.5 x 8 x $4.50 = $18.00 at the Nebius on-demand rate.
The bigger cost is the gap before training restarts. On Nodus that gap is the time to prepare a new machine. On a preemptible VM it lasts until a person or a script you wrote brings the job back.
Should you use Nebius preemptible VMs or Nodus for a long run?
Use this rule: pick Nebius preemptible VMs if you already have tooling that restarts and resumes jobs, and pick Nodus if you don't want to build it. The preemptible discount is real, but you only keep it if interruptions cost you minutes, not an evening.
A team with a Slurm requeue setup or a Kubernetes controller that relaunches failed pods already has most of the recovery machinery, and Nebius's spot floor is hard to beat. A team running one script on one machine usually does not. For them, a lower on-demand rate plus automatic recovery is the simpler way to finish a long run without supervision.
Nodus has its own interruptible option. Add --interruptible to a run and Nodus may place it on reclaimable machines, with the same checkpoint and replacement flow described above. For the code side, see how to resume training after a spot preemption, and for when interruptible capacity pays off, spot vs on-demand GPUs.
Can you use Nodus with your Nebius account?
Yes, in Beta. If you hold Nebius credits, you can connect your Nebius project to Nodus with a service account key and a credit limit. Nodus then places Jobs, Workspaces and other single-node work in that project first, with Nodus checkpoints, recovery and caps on top (connect your cloud accounts). The feature is turned on per organization, so ask Nodus support first.
The key comes from nebius iam auth-public-key generate for a service account in the project's editors group. Then connect it from the CLI:
nodus cloud connect nebius my-nebius --credit-limit 2000 --key-env NEBIUS_PRIVATE_KEY \
--field serviceAccountID=serviceaccount-… --field publicKeyID=publickey-… \
--field projectID=project-… --field region=eu-north1
Nodus creates machines only in that project and never touches anything else in it. When the credit limit runs out, --burst decides what happens next: run on Nodus capacity (the default), wait for your approval, or wait for your account. Sandboxes and multi-node runs use Nodus capacity, and each attempt's page shows where it ran.
Where is Nebius the better choice?
Pick Nebius in these cases:
- You are training across many nodes and need a fast fabric. Nebius GPU clusters connect every GPU over InfiniBand at 400 Gbps, 3.2 Tbps per 8-GPU node, with GPUDirect RDMA (GPU clusters). Multi-node training on Nodus is in Beta, limited to 8 nodes, and public traffic between nodes is not encrypted in the Beta (multi-node guide).
- You want capacity reserved for months at a discount. Nebius commitment discounts cover GPUs, disks and shared filesystems, for example 64 VMs of 8 x H100 for 365 days (commitment discounts). Nodus publishes no long-term discount; its Reserved Compute is in Beta and quoted by proposal (Reserved Compute).
- Your team already runs Kubernetes or Slurm. Nebius offers Managed Kubernetes and Managed Soperator, a Slurm-on-Kubernetes system that Nebius publishes as open source, with health checks that replace broken worker nodes (Soperator).
- You need GB200 or GB300 NVL72 rack-scale systems. Nebius lists both on its pricing page, through sales. Nodus does not list them.
- Your main workload is inference on open models. Token Factory offers an OpenAI-compatible API with dedicated endpoints and batch inference (Token Factory). Hosted inference on Nodus is in Beta.
- You can run interruptibly and already handle restarts. At its floor, Nebius preemptible pricing is well below any on-demand rate in this post.
How do you move a Nebius training script to Nodus?
Make the checkpoint path read from the Nodus state directory, with your Nebius path as the fallback, and the same script runs in both places:
import os, torch
STATE_DIR = os.environ.get("NODUS_STATE_DIR", "/mnt/ckpt") # /mnt/ckpt: wherever your Nebius disk is mounted
CKPT = os.path.join(STATE_DIR, "ckpt.pt")
def save(step, model, opt):
os.makedirs(STATE_DIR, exist_ok=True)
tmp = CKPT + ".tmp"
torch.save({"model": model.state_dict(), "opt": opt.state_dict(), "step": step}, tmp)
os.replace(tmp, CKPT) # atomic swap, so a restore never reads a half-written file
def load(model, opt):
if not os.path.exists(CKPT):
return 0
s = torch.load(CKPT)
model.load_state_dict(s["model"]); opt.load_state_dict(s["opt"])
return s["step"]
Check the estimate, then launch with a cap a little above it:
nodus run --dry-run --gpu H100:8 --expected-duration 24h -- torchrun --nproc_per_node 8 train.py
nodus run --gpu H100:8 --checkpoint /nodus/state --max-cost 550 -d -- torchrun --nproc_per_node 8 train.py
Nodus restores files, not process memory, so your program must call load() when it starts. If you are comparing more than two options, the Nodus vs RunPod comparison works through the same questions for RunPod.
FAQ
Does Nebius bill preemptible VMs at a fixed price?
No. Preemptible VMs are charged at the current spot price, and you can either set a maximum price through a pricing policy or follow the spot price with no maximum (preemptible VMs). L40S preemptible instances are the exception: Nebius bills them at a flat rate (pricing notes).
What happens on each platform when the money runs out?
On Nodus, a checkpointed Job takes an urgent checkpoint, suspends, and resumes on its own after a top-up (when money runs out). Nebius charges cards monthly or at a billing threshold, and says that if a threshold charge fails, your account and access to resources may be suspended (billing threshold).
Can I cap what one training run spends?
On Nodus, --max-cost sets a dollar cap per run, and a checkpointed Job that reaches it checkpoints and suspends until you raise the cap. On Nebius, the closest tools are budgets that alert you as spending grows and a maximum spot price for preemptible VMs.
Can I convert a running Nebius VM to preemptible to save money?
No. Nebius does not convert an existing VM between regular and preemptible, so you create a new preemptible VM instead (preemptible VMs). That is another reason to keep checkpoints on a volume or shared filesystem that a new VM can mount.
Originally published on the Nodus blog.
Top comments (0)