Salad Cloud Review 2026: $0.20/hr 4090s on Gaming PCs — Too Cheap to Be True?
Salad’s headline price is striking: RTX 4090 at $0.20 per hour, RTX 5090 at ~$0.294 per hour (salad.com pricing, June 2026). That is 50–70% cheaper than what datacenter providers like RunPod or Lambda charge. The honest question is not “Is this real?” but “What am I trading for it?” The answer is reliability. Salad rents idle compute on 60,000+ consumer gaming PCs, and when the owner wants their machine back — or decides to play a game — your inference job stops. This guide is for people choosing Salad: when the price advantage justifies the tradeoff, and when a datacenter provider makes more sense.
How Salad works: scaling across consumer hardware
Salad’s model is fundamentally different from renting a cloud GPU. Instead of a datacenter machine that belongs to the cloud provider, Salad aggregates idle compute from consumer PCs — gaming rigs, workstations, even older miners. The owner installs Salad software, and when the machine is not in use, Salad can lease it to run your job.
This is why the prices are so low. Salad does not own or maintain the hardware. It does not pay for a data-center facility, power infrastructure, or customer support SLAs. The owner is incentivized to keep the machine available in the Salad network (they earn a small cut of the compute rental). That economics-of-scale approach lets Salad undercut datacenter pricing by half.
The flip side: if the owner needs their machine, your job evicts. If the GPU thermal throttles or the ISP hiccups, you see it instantly. If the host machine runs Windows updates at 4 a.m. your time, your training checkpoint is lost. You are not renting a machine — you are renting idle time on someone else’s machine.
When Salad wins: stateless and checkpointed work
Salad is the right choice for specific workloads, and it is genuinely excellent at them.
Batch inference at scale. If you are running a text API endpoint against a 7B or 13B model, and each request is independent, Salad’s interruption risk is low for any single request. Spin up a container, run inference on a batch of prompts, save results, and shut down. If a job fails partway through, you retry on a fresh node. Salad’s price advantage can reduce the per-token cost of inference by 50–70% over datacenter options.
Checkpointed fine-tuning. You can fine-tune on Salad if you design for interruption. Save the model weights every 100–500 steps, and load the last checkpoint if the job restarts. With this pattern, Salad is stable enough for a 24-48 hour fine-tuning run on a niche model or dataset. The per-hour cost is a fraction of what you would pay on RunPod.
Burst compute. If your workload is spiky — you need 10 GPUs for 4 hours on Tuesday, then nothing for a week — Salad is cost-effective. Rent the GPUs, finish the job, check the checkpoint, and release. Datacenter providers charge you by the minute or hour even for brief bursts; Salad’s commodity pricing rewards quick, tight workloads.
Model evaluation and benchmarking. Running evals across 20 model variants or quantization levels? Stateless evals are interruption-insensitive. You can run them on a fleet of Salad nodes in parallel, collect the scores, and shut down. The price per eval is so low it barely shows on your budget.
When Salad loses: stateful and long-running work
Salad is the wrong choice when reliability is non-negotiable or your workload cannot tolerate interruption.
Production inference services. If you are running an API that customers depend on, and the API is down when a Salad node evicts, you lose trust and revenue. Datacenter providers (Vast.ai, RunPod, Lambda) offer uptime SLAs and easier failover. The 50% price discount is not worth the support load.
Long fine-tuning runs without checkpoints. If you are training for 8 hours on a dataset you cannot easily re-sample, and you have not baked in auto-save, a node failure at hour 7 loses all progress. The cost to implement checkpointing is low; the risk is high if you skip it. Datacenter hardware is far more reliable for this.
Real-time applications. Anything that requires sub-second latency or cannot tolerate a 30-minute eviction is wrong for Salad. Games, live demos, and user-facing tools all fit here.
Multi-day training. Training a large model for 72+ hours on Salad is high-risk unless you have battle-tested checkpoint logic and a pipeline to resume on a different node. For safety, datacenter hardware is the right bet.
Comparison: Salad vs. other GPU cloud providers
| Provider | RTX 4090 $/hr | RTX 5090 $/hr | Uptime SLA | Interruption model | Best for |
|---|---|---|---|---|---|
| Salad | $0.20–0.25 | $0.29–0.35 | None | Consumer-owned (frequent) | Batch work, short evals |
| Vast.ai | $0.40–0.65 | $0.50–0.80 | Optional (some hosts) | Consumer-owned (configurable) | Balanced cost/reliability |
| RunPod | $0.45–0.70 | $0.65–0.95 | 99%–99.9% (tier-dependent) | Datacenter (rare) | Production, long jobs |
| Lambda Labs | $0.60–0.85 | $0.80–1.20 | 99.9% | Datacenter (rare) | High-reliability inference |
Salad is the cheapest on raw hourly rate. Vast.ai sits in the middle — consumer rented hardware, but with options for more reliable hosts and capped interruption frequency. RunPod and Lambda charge a premium but offer infrastructure SLAs and predictable uptime. The right choice depends on whether you need the price or the guarantee.
Hidden costs and real tradeoffs
Salad’s low hourly rate does not capture the full cost of reliability. There are hidden factors to account for:
Retry and fault-handling logic. Every Salad job needs to be idempotent or checkpointed. Writing fault-tolerant code is not free. If you spend 40 hours engineering a robust checkpoint pipeline for a job that would have cost $40 on Salad, the tradeoff is real. For short jobs, the margin is not worth it.
Time to completion. If a Salad node interrupts 12 hours into a 20-hour run, you have wasted 12 hours and have to restart. On a reliable datacenter node, the job would finish. Multiply the cost of latency (missed deadline, blocked downstream work, your own time) against the $15–20 you saved on GPU rental. Salad’s price advantage evaporates fast.
Node quality variance. Salad’s 60,000-node network is not homogeneous. Some hosts run gaming PCs with dedicated fiber; others are on cable internet with aggressive thermal throttling. You cannot hand-pick your node, so you might land on a slow or flaky one. Spinning up a fresh node is a manual retry, not an automatic failover.
Setup and monitoring. Salad does not have the one-click deployment tooling that RunPod offers. You need to containerize your job, understand Salad’s API, set up logging, and manage restarts yourself. If you value your time, factor that overhead in.
Is Salad legitimate?
Yes. The company is venture-backed (Series B, raised by Greycroft and others), has been operating since 2018, and pays hosts reliably. The pricing is not a scam — it is a coherent economics model. The risk is not fraud; it is interruption frequency. Community reports (r/LocalLLaMA, cloud-compute subreddits, 2025–2026) range widely: some users report Salad nodes stable for days; others see interruptions every 2–3 hours. It depends on the host, the region, and how heavily the node is oversold.
Do not assume Salad is illegitimate because the price is low. Assume it is legitimate but requires you to design for unreliability.
Salad vs. running your own hardware
If you already own a local GPU (a used RTX 3090, for example), should you ever use Salad? Yes — for short bursts or parallel work. Rent 10 Salad nodes for 4 hours to eval a new model. The cost is ~$20 and the job parallelizes. Renting time is often cheaper than buying a second local GPU and then idle between jobs. For occasional scaling, Salad is a smart cloud onramp. For continuous workloads, a local GPU wins on cost-per-hour over time.
See rent vs. buy GPU break-even for the math on when owning becomes cheaper than renting.
Alternatives if reliability matters
If Salad’s interruption frequency is a dealbreaker, you have two paths:
-
Vast.ai with filter rules. Vast.ai uses the same consumer-rented hardware model as Salad, but you can filter for high-uptime, low-interruption hosts, and even configure a bid-interruptible vs. guaranteed uptime mix. You will pay more than Salad, but less than datacenter providers. See Vast.ai review for the details.
-
Datacenter providers (RunPod, Lambda, DigitalOcean). If uptime is critical, pay the premium. The cost difference is real — RunPod’s cheapest 4090 is roughly $0.50–0.70/hr vs. Salad’s $0.20. But the SLA is explicit, failover is automated, and you do not gamble on node reliability. For production inference or long training runs, the guarantee pays for itself.
-
TensorDock. See TensorDock review for another mid-market option between Salad and enterprise cloud providers.
Bottom line
Salad is the cheapest GPU cloud option available, at $0.20/hr for an RTX 4090. That price is real and stable. The catch is equally real: you are renting idle time on consumer machines, and interruptions are part of the deal. Buy it if your workload is stateless, checkpointed, or bursty. Do not expect it to run a production service or an 8-hour uninterrupted training job without friction. For anything longer or more critical, pay the 50% premium for a datacenter provider and sleep better.
The decision comes down to a single question: Is this work worth the price savings, or is uptime worth the premium? Answer that honestly, and the choice is obvious.