Paperspace vs Verda
Both rent GPU and CPU virtual machines that you reach over SSH. Paperspace, part of DigitalOcean, bills by the hour in New York, Amsterdam and Canada, while Verda (formerly DataCrunch) runs only in Helsinki, with newer Nvidia GPUs, GPU clusters and very large CPU machines.
The companies and products
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
Verda
Verda, called DataCrunch until 2025, is a European AI cloud that rents Nvidia GPUs, CPU machines and GPU clusters.
You create a GPU or CPU instance, add a disk and an SSH key, and get a full Linux VM with root and its own public IP. Verda also sells GPU clusters with InfiniBand and serverless containers that scale to zero for inference. It is built for teams that train, fine-tune and serve AI models, not as a sandbox for agents.
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. “58th cheapest of 364” means 57 of the other 363 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 | Paperspace: price rank | Verda: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both give you a raw VM that you set up over SSH, so a fleet of coding agents is a compromise on either; bochka ranks 3rd with agents preinstalled. | 141st of 367, with limits $1,261 a month | 88th of 367, with limits $788 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 179th of 366, with limits $1,560 a month | 133rd of 366, with limits $901 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 Verda's serverless containers scale to zero and wake on a request, which suits short bursts better than Paperspace's hourly billing or bochka's start limits. | 179th of 345, with limits $1,451 a month | 99th of 345, with limits $165 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 gives you an API to run code inside a machine, and Verda does not publish how many machines can run at once, so bochka ranks 1st here. | 124th of 361, with limits $1,243 a month | 71st of 361, with limits $629 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 Verda ranks 20th for RL rollouts and Paperspace ranks 193rd, since Paperspace bills each short run as a full hour; bochka ranks 34th. | 193rd of 360, with limits $30,570 a month | 20th of 360, with limits $1,097 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 | 58th cheapest of 364 $1,241 a month | 91st of 364, with limits $123 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 All three fit: Verda ranks 10th with dedicated EPYC cores, Paperspace bills a full hour per runner, and bochka ranks 4th with per-second billing and free stops. | 101st cheapest of 377 $1,026 a month | 10th cheapest of 377 $142 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB All three fit a dev box that never stops; Verda's smallest CPU machine has 16 GB of memory, and Paperspace adds a disk and public IP fee. | 49th cheapest of 368 $63 a month | 36th cheapest of 368 $45 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 Paperspace streams a desktop only on Windows machines, which new users cannot create, and Verda only has a guide to install VNC yourself; bochka ships a 60fps desktop. | 284th of 369, with limits $1,655 a month | 82nd of 369, with limits $123 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 | 319th of 367, with limits $1,241 a month | 169th of 367, with limits $110 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 | 192nd of 346, with limits $112 a month | 184th of 346, with limits $103 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 | 92nd of 338, with limits $2,242 a month | 84th of 338, with limits $2,057 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 | 207th of 360, with limits $214 a month | 122nd of 360, with limits $66 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 Both fit GPU eval jobs: Verda ranks 14th with newer cards like B200 and GB300, Paperspace ranks 30th, and bochka has no GPUs. | 30th cheapest of 98 $2,982 a month | 14th cheapest of 98 $1,039 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 | Paperspace | Verda | bochka |
|---|---|---|---|
| Kind of product | GPU and CPU VM cloud for machine learning, part of DigitalOcean | GPU and CPU cloud: VMs, GPU clusters and serverless containers | Sandbox cloud for agents: VMs you create, fork and drive from code |
| Isolation | Every machine is a full VM with its own kernel | Every instance is a full VM on KVM/QEMU | Every sandbox is a full VM with its own kernel |
| GPUs | Nvidia M4000 up to A100 and H100 (H100 needs approval), up to 8 per machine | Nvidia V100 up to B200, B300 and GB300, on-demand or spot, plus clusters with InfiniBand | None |
| Largest CPU machine | C10: 32 vCPU / 244 GB | Up to 360 dedicated AMD EPYC vCPU / 1,440 GB | 16 vCPU / 32 GB |
| Regions | New York, Amsterdam and Canada | EU only: three data centers in Helsinki, Finland | EU only: Germany, Finland, France |
| Billing step | Per hour | Prepaid 10-minute blocks, unused part refunded on delete | Per second |
| Stopping a machine | Compute stops billing; the disk and public IP keep billing | A shut-down instance keeps billing at full rate; only Delete stops it | A stopped sandbox costs nothing and keeps its disk |
| Snapshots and copies | Auto-snapshots at most hourly; a template needs the machine turned off | Clone a volume once its instance is shut down; no snapshots of a running machine | Snapshots every minute and on stop; fork a running sandbox in one call |
| Docker and nested virtualization | Docker runs inside; nested virtualization is not documented | Root on your VM, so you can install Docker; nested virtualization is not documented | Docker, root, systemd and /dev/kvm on every machine |
| Working inside from code | API and CLI manage machines but cannot connect to them; you use SSH | API, CLI and an MCP server manage machines; you work inside over SSH | API, SDK and CLI to run commands, move files and fork |
| Coding agents and desktop | No agents built in; desktop streaming only on Windows, closed to new users | No agents built in; a guide to install XFCE and TigerVNC yourself | Claude Code, Codex, OpenCode and more preinstalled; 60fps desktop with Chromium and computer use |
| Reaching the machine | A public IPv4 on every Linux machine; no managed HTTPS URLs | A free public IPv4 per instance; you set up TLS and the firewall | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Keeping keys out of the machine | No credentials proxy; Gradient secrets become environment variables | Secrets only for serverless containers; on instances you place keys yourself | AI credentials proxy for model providers and any HTTPS API you register |
| Scale to zero | No wake on request | Serverless containers sleep when idle and start on the next request | No wake on request; you start a stopped sandbox through the API |
Every feature Battleships tracks (43)
| Feature | Paperspace | Verda | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Not published | Not published | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | 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 | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | Yes | 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 | Yes | No | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | No | Yes | Yes |
| Raw TCP inbound | Not published | No | 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 | No | Yes | 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 | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Paperspace or Verda: neither was part of the public StarSling benchmark run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts. Verda says its CPU instances use dedicated AMD EPYC cores clocked at 3.3 GHz.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Paperspace and Verda 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 | Paperspace, a month | Verda, 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 | $19 · Core usage | $18 · Pay as you go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $63 · Core usage | $45 · Pay as you go | $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 | $804 · Core usage | $622 · Pay as you go | $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 | $1,241 · Core usage | $254 · Pay as you go · with limits | $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 | $8,274 · Core usage | $507 · Pay as you go · with limits | $2,000 · $2000/mo · with limits |
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.
Verda: Verda charges a prepaid balance in 10-minute blocks and refunds the unused part when you delete early. CPU machines cost $0.012 per vCPU-hour with 4 GB of RAM each, the disk is $0.20/GiB-month, and a shut-down instance keeps billing until you delete it.
Verda: 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 disk.
Limits in those scenarios
Paperspace bills by the hour, so short sessions cost far more there: sandboxes for your users come to $1,241 a month against $254 on Verda. Verda does not publish how many instances an account can run at once, so 300 user sandboxes or 1,000 jobs at once are not confirmed until you get a higher quota, while Paperspace has no start limits and fits the burst at $8,274 a month. Verda's smallest CPU machine is 4 vCPU / 16 GB, so small sandboxes cost the same as medium ones. On bochka the 1,000-job burst is queued and needs more starts per day than the $2,000 plan allows.
| Scenario | Paperspace | Verda | 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 Paperspace when
you need GPU or CPU machines in the US or Canada, or want a machine that stops its compute charge when you turn it off.
- Machines in North America. Useful if your users or data sit in North America: Paperspace runs in New York and Canada as well as Amsterdam.
- Turning off saves the compute charge. Useful for machines you use part of the day: a turned-off Paperspace machine stops its hourly charge, while a shut-down Verda instance keeps billing.
- A wide range of older GPUs. Useful for light GPU work: Paperspace still rents older cards like the P4000 and RTX4000 alongside A100 and H100.
Use Verda when
you need the newest Nvidia GPUs, GPU clusters, a very large CPU machine, or inference containers that scale to zero, and Finland suits your data.
- Newest GPUs and clusters. Useful for large training runs: Verda rents B200, B300 and GB300 GPUs, spot machines, and clusters with InfiniBand.
- Very large CPU machines. Useful for one huge job: Verda CPU instances go up to 360 dedicated vCPU and 1,440 GB, against 32 vCPU on Paperspace.
- Containers that scale to zero. Useful for inference endpoints and short bursts: Verda's serverless containers sleep when idle and wake on the next request.
Where bochka fits
Paperspace and Verda are GPU clouds, and bochka has no GPUs, so model training belongs on one of them. If what you are really running is agents, both hand you a raw VM to set up over SSH, and bochka gives each agent a VM that code can create, fork and drive, with agents and a desktop inside.
Free stops and snapshots every minute
Agents sit idle between tasks. A shut-down Verda instance keeps billing at full rate, a stopped Paperspace machine still bills its disk and IP, and both save at most hourly or only when stopped. bochka stops for free and snapshots every minute.
Driven from code, with agents inside
Neither API can run a command inside a machine, so you build and maintain your own SSH layer and install each agent. bochka runs commands, moves files and forks from an API, with Claude Code and Codex preinstalled.
Desktop, HTTPS ports and keys kept out
Computer use on Paperspace needs Windows, closed to new users, and on Verda a VNC server you install. Both leave TLS and API keys on the machine to you. bochka has a 60fps desktop, HTTPS on 50 ports and a credentials proxy.
Use bochka when you run agents rather than train models: VMs that code can create, fork and drive, with coding agents, a desktop, HTTPS ports and free stops built in. Compare it one to one: bochka vs Paperspace and bochka vs Verda.
Questions people ask
Is Paperspace cheaper than Verda?
Usually not. One coding agent on workdays is about even ($19 on Paperspace, $18 on Verda), but one agent running all month is $63 against $45, and 50 agents in parallel are $804 against $622. bochka comes to $26 and $317 for those two.
Which is faster, Paperspace or Verda?
There is no comparable CPU measurement for either. Verda says its CPU machines use dedicated AMD EPYC cores at 3.3 GHz. bochka scored 26.69 runs per second at 4 vCPU / 8 GB in the public StarSling run.
Which has better GPUs?
Verda has the newer cards: B200, B300 and GB300, plus spot machines and InfiniBand clusters. Paperspace goes from older cards like the M4000 up to A100 and H100, and H100 needs approval. bochka has no GPUs.
Can Paperspace and Verda run Docker?
Yes. Both give you a full Linux VM with root, so Docker runs inside, though neither documents nested virtualization. bochka has Docker, systemd and /dev/kvm on every sandbox.
Does a stopped machine cost money?
On Paperspace, a turned-off machine stops its compute charge but its disk and public IP keep billing. On Verda a shut-down instance keeps billing at full rate until you delete it. A stopped bochka sandbox costs nothing and keeps its disk.
Where do Paperspace and Verda run?
Paperspace runs in New York, Amsterdam and Canada. Verda runs only in three data centers in Helsinki, Finland. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview