Runpod vs Paperspace
Both are GPU clouds, but they rent different things. Runpod gives you containers billed by the second, plus serverless workers that scale to zero, while Paperspace gives you full Linux VMs billed by the hour that you work in over SSH.
The companies and products
Runpod
Runpod is a GPU cloud for AI work: you rent GPU or CPU pods by the second, run serverless endpoints, or book multi-node GPU clusters.
A Runpod Pod is a container started from a Docker image, with a GPU or CPU-only, SSH, a web terminal and Jupyter. Serverless endpoints run your handler in workers that scale to zero and start on a request, and Instant Clusters join 2 to 8 nodes of 8 GPUs each. It is built for teams that train, fine-tune and serve models, not as a sandbox API for agents, so this page compares the parts that overlap: CPU pods as machines for agent work.
- Founded
- 2022
Paperspace
Paperspace is a GPU cloud for machine learning, owned by DigitalOcean since 2023.
Paperspace Machines are full Linux VMs with a persistent disk, a public IP and optional Nvidia GPUs from M4000 up to H100, billed by the hour. Next to Machines it sells Gradient Notebooks, Deployments and Workflows for training and serving models. It is built for people who train, test and run models, not as a sandbox API: its API manages machines, and you work inside them over SSH.
- Operating systems
- Linux; Windows templates closed to new users since 1 July 2024
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “32nd cheapest of 377” means 31 of the other 376 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Runpod: price rank | Paperspace: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither is a clean fit: a Runpod pod cannot run Docker inside, and a Paperspace VM runs Docker but is set up by hand over SSH; bochka gives each agent a VM with Docker and agents built in. | 203rd of 367, with limits $2,362 a month | 141st of 367, with limits $1,261 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 211th of 366, with limits $2,290 a month | 179th of 366, with limits $1,560 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month For short code runs Runpod comes to $135 a month against $1,451 on Paperspace, because Runpod bills by the second and Paperspace bills by the hour. | 227th of 345, with limits $135 a month | 179th of 345, with limits $1,451 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Neither has an API to run code inside a machine for your users; Runpod does not publish how many pods can run at once, and Paperspace bills a full hour for each short session. | 83rd of 361, with limits $733 a month | 124th of 361, with limits $1,243 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Runpod comes to $3,068 a month for this workload against $30,570 on Paperspace; bochka is a compromise too, at $2,000 a month. | 53rd of 360, with limits $3,068 a month | 193rd of 360, with limits $30,570 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 127th of 364, with limits $614 a month | 58th cheapest of 364 $1,241 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit plain build and test jobs; jobs that start Docker containers work on a Paperspace VM and on bochka, but not in a Runpod pod. | 32nd cheapest of 377 $301 a month | 101st cheapest of 377 $1,026 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Paperspace fits a dev box that never stops, since its whole disk survives a stop; on Runpod anything installed outside /workspace is gone after a stop. | 161st of 368, with limits $93 a month | 49th cheapest of 368 $63 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither gives a Linux desktop: Runpod pods have a terminal, SSH and Jupyter, and Paperspace streams a desktop only on Windows machines that new users cannot create; bochka streams a 60fps desktop. | 189th of 369, with limits $614 a month | 284th of 369, with limits $1,655 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 224th of 367, with limits $307 a month | 319th of 367, with limits $1,241 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 225th of 346, with limits $202 a month | 192nd of 346, with limits $112 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 138th of 338, with limits $4,035 a month | 92nd of 338, with limits $2,242 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 180th of 360, with limits $161 a month | 207th of 360, with limits $214 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Runpod ranks 13th of 98 and Paperspace ranks 30th, because Runpod rents more GPU types by the second; bochka has no GPUs. | 13th cheapest of 98 $1,001 a month | 30th cheapest of 98 $2,982 a month | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Runpod | Paperspace | bochka |
|---|---|---|---|
| Kind of product | GPU cloud: container Pods, Serverless endpoints and multi-node Clusters | GPU and CPU VM cloud for machine learning, owned by DigitalOcean | Sandbox cloud for agents: VMs you create, fork and drive from code |
| Isolation | Containers that share the host kernel | Every machine is a full VM with its own kernel | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Root in the container; no Docker or Docker Compose inside a pod | Docker runs inside; nested virtualization is not documented | Docker, Docker Compose, root, systemd and /dev/kvm on every machine |
| Files after a stop | Only /workspace is kept, billed at double the running rate; the rest of the container disk is cleared | The whole disk is kept and billed while off; auto-snapshots at most hourly | The whole disk is kept, snapshots every minute and on stop; a stopped sandbox costs nothing |
| Copying a machine | No pod fork or snapshot; templates save the image and settings only | Custom templates from a machine that is turned off, same region only | Fork a running sandbox into a new one with the same disk |
| Working inside from code | Web terminal, SSH and JupyterLab; an MCP server lets your own agent manage pods | The API and CLI manage machines but cannot connect to them; you use SSH | API, SDK and CLI to run commands, move files and fork |
| Coding agents | Nothing runs an agent inside a pod for you | None built in; ML templates such as ML-in-a-Box | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Desktop and computer use | No desktop | Desktop streaming only on Windows machines, which new users cannot create | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Reaching the machine | Up to 10 HTTP ports on a public proxy URL with no built-in auth; TCP ports on a public IP | A public IPv4 on every Linux machine, any port; no managed HTTPS URLs | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Keeping keys out of the machine | Secrets are passed into the pod as environment variables | No credentials proxy; Gradient secrets are injected as environment variables | AI credentials proxy for model providers and any HTTPS API you register |
| GPUs | Dozens of Nvidia and AMD types, from RTX A4000 to B300 and MI300X, plus multi-node clusters | Nvidia GPUs from M4000 to H100, up to 8 per machine; H100 needs approval | None |
| Scale to zero | Serverless workers scale to zero and start when a request arrives | Optional auto-shutdown after one hour to one week; no start on a request | Sandboxes stop and resume by API; no start on an incoming request |
| Billing step | Per second, from a prepaid balance | Per hour while the machine is on | Per second, from monthly plan credit |
| Regions | 24 documented data centers in the US, Canada, Europe and Australia | New York, Amsterdam and Canada | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Runpod | Paperspace | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Not published | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | Yes | Yes | No |
| Egress allowlist | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Runpod or for Paperspace: neither is in the public StarSling benchmark run we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Runpod and Paperspace have no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Runpod, a month | Paperspace, a month | bochka, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $26 · Pay-as-you-go (prepaid credits) · with limits | $19 · Core usage | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $93 · Pay-as-you-go (prepaid credits) · with limits | $63 · Core usage | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $1,156 · Pay-as-you-go (prepaid credits) · with limits | $804 · Core usage | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $307 · Pay-as-you-go (prepaid credits) · with limits | $1,241 · Core usage | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $614 · Pay-as-you-go (prepaid credits) · with limits | $8,274 · Core usage | $2,000 · $2000/mo · with limits |
Runpod: Runpod bills a running pod per second from a prepaid balance, with disk on top, and a stopped pod keeps billing its /workspace volume at double the running rate. CPU pod rates come from Runpod's public CPU catalogue, and a new pod needs at least one hour of credit to start.
Paperspace: Paperspace bills each machine per hour while it is on, at a fixed rate per size (C5, 4 vCPU / 8 GB, is $0.08 an hour). The boot disk (from $5 a month for 50 GB) and the public IP keep billing until you delete the machine, even when it is off.
Paperspace: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its whole disk.
Limits in those scenarios
Every Runpod scenario hits the /workspace rule: packages installed anywhere else are gone after a stop, and 50 agents with Docker inside do not fit because pods cannot run Docker. Runpod also does not publish how many pods can run at once; it caps spend at $80 an hour by default instead. Paperspace fits every scenario but bills by the hour, so 1,000 short jobs at once come to $8,274 a month there against $614 on Runpod. On bochka that burst is queued by start limits and needs more starts per day than the $2,000 plan allows.
| Scenario | Runpod | Paperspace | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
Which one should you use?
Use Runpod when
you need the widest choice of GPUs, multi-node clusters, serverless workers that start on a request, or per-second billing for short GPU jobs.
- More GPU types, up to clusters. For training and serving models: Runpod rents dozens of Nvidia and AMD GPUs, up to B300 and multi-node clusters.
- Serverless that scales to zero. For spiky work: Runpod Serverless workers sit at zero when idle and start when a request comes in.
- Per-second billing and more regions. For short jobs or data outside the EU: pods bill by the second, in the US, Canada, Europe and Australia.
Use Paperspace when
you want a full GPU or CPU VM with Docker inside and a disk that survives stops, set up and used by a person over SSH.
- A full VM with Docker inside. For work that needs its own kernel: each Paperspace machine is a full VM, and Docker runs inside it.
- The whole disk survives a stop. For long-lived machines: a stopped Paperspace machine keeps its whole disk, not only one folder.
- Big CPU machines with a public IP. For heavy single jobs: CPU machines go up to 32 vCPU and 244 GB, each with its own public IPv4.
Where bochka fits
Runpod and Paperspace are GPU clouds, and if your work needs GPUs, one of them is the right place for it. If what you are really running is agents that write and run code on CPU machines, bochka gives each one a full VM built for that, with Docker, a desktop and coding agents inside. You can also use both: a GPU cloud for the models, bochka for the agents.
A full VM with Docker and /dev/kvm
Coding agents run docker compose, test containers and emulators. A Runpod pod cannot run Docker inside, and Paperspace runs Docker but documents no nested virtualization, so emulators and VMs inside are not covered.
Agents inside, driven from outside
bochka ships Claude Code, Codex and others in each sandbox, with an API to prompt, steer and watch them. Paperspace's API cannot reach inside a machine and Runpod runs no agent for you, so you build and maintain that layer over SSH.
Disk saved every minute, fork while running
A Runpod stop clears everything outside /workspace, and Paperspace snapshots at most hourly, with copies made only from a turned-off machine. bochka saves the whole disk every minute, stops for free and forks a running sandbox.
Use bochka when the work is agents writing and running code: each gets a full VM with Docker and /dev/kvm, a disk saved every minute, fork, a desktop and coding agents built in. Compare it one to one: bochka vs Runpod and bochka vs Paperspace.
Questions people ask
Is Runpod cheaper than Paperspace?
It depends on the job. For long-running CPU machines Paperspace comes out lower: one agent that never stops is $63 a month there against $93 on Runpod, and 50 agents in parallel $804 against $1,156. For short sessions Runpod wins because it bills by the second: sandboxes for your users are $307 on Runpod against $1,241 on Paperspace. bochka comes to $26, $317 and $200 for those three.
Which is faster, Runpod or Paperspace?
We have no comparable CPU measurement for either one, so we cannot say. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public benchmark run of 2026-09-29.
Can Runpod or Paperspace run Docker?
Paperspace can: each machine is a full VM and Docker runs inside it. Runpod cannot: its docs say you cannot start your own Docker or use Docker Compose on a pod. bochka runs Docker, Docker Compose and /dev/kvm on every sandbox.
Which has better GPUs?
Runpod has the wider range: dozens of Nvidia and AMD types up to B300 and MI300X, and multi-node clusters. Paperspace rents Nvidia GPUs from M4000 to H100, up to 8 per machine, and H100s need approval. bochka has no GPUs.
What happens to my files when a machine stops?
On Runpod only /workspace is kept, and you keep paying for it; the rest of the container disk is cleared. On Paperspace the whole disk is kept and keeps billing while the machine is off. On bochka the whole disk is kept, snapshotted every minute, and a stopped sandbox costs nothing.
Where do Runpod and Paperspace run?
Runpod documents 24 data centers in the US, Canada, Europe and Australia. Paperspace runs machines in New York, Amsterdam and Canada. bochka runs only in the EU (Germany, Finland and France), with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview