Runpod vs Verda
Runpod and Verda are both GPU clouds. Runpod gives you containers billed by the second in data centers across the US, Canada, Europe and Australia, while Verda gives you full virtual machines in Helsinki, billed in 10-minute blocks.
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
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. “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 | Verda: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Verda's full VMs can run Docker while a Runpod pod cannot, but both leave you to set up the agent, and bochka is the only full fit here. | 203rd of 367, with limits $2,362 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 | 211th of 366, with limits $2,290 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 Both have serverless containers that scale to zero and start on a request, which suits short code runs better than bochka's start limits. | 227th of 345, with limits $135 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 publishes how many machines can run at once, so 300 sandboxes for your users is not confirmed on Runpod or Verda. | 83rd of 361, with limits $733 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 higher than Runpod for RL rollouts, helped by cheaper CPU hours, though both stay a compromise without a sandbox API. | 53rd of 360, with limits $3,068 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 | 127th of 364, with limits $614 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 for build and test jobs; Verda comes to $142 a month against $301 on Runpod, and bochka to $86. | 32nd cheapest of 377 $301 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 Verda fits a 24/7 dev box because the whole VM disk stays; on Runpod anything installed outside /workspace is gone after a stop. | 161st of 368, with limits $93 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 Neither has a built-in desktop: on Verda you install a VNC server yourself, on Runpod there is none, while bochka streams a 60fps desktop. | 189th of 369, with limits $614 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 | 224th of 367, with limits $307 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 | 225th of 346, with limits $202 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 | 138th of 338, with limits $4,035 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 | 180th of 360, with limits $161 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 and sit next to each other in the table: Runpod comes to $1,001 a month and Verda to $1,039, and bochka has no GPUs. | 13th cheapest of 98 $1,001 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 | Runpod | Verda | bochka |
|---|---|---|---|
| Isolation | Containers that share the host kernel | Every instance is a full VM on KVM/QEMU | Every sandbox is a full VM with its own kernel |
| Docker inside | Root in the container; no Docker or Docker Compose inside a pod | Root on your own VM, so you can install Docker | Docker, Docker Compose, root and systemd on every machine |
| Nested virtualization | None documented; pods are containers | Not documented | /dev/kvm on every machine, so emulators and VMs run inside |
| GPUs | Dozens of Nvidia and AMD types, from RTX A4000 to B300 and MI300X, plus multi-node clusters | Nvidia V100 up to GB300, on-demand or spot, plus clusters with InfiniBand | None |
| Biggest CPU machine | CPU pods with 2 GB of RAM per vCPU | CPU instances up to 360 dedicated vCPU / 1,440 GB | 16 vCPU / 32 GB on the $100 plan and up |
| Stopping a machine | A stopped pod keeps only /workspace and bills that volume at $0.20/GB-month | A shut-down instance keeps billing at its full rate; only Delete stops the charge | A stopped sandbox costs nothing and keeps its whole disk |
| Snapshots and fork | No pod snapshot or fork; templates save the image and settings only | 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 |
| Desktop and computer use | Web terminal, SSH, JupyterLab and remote VS Code or Cursor; no desktop | No built-in desktop; a guide to install XFCE and TigerVNC yourself | 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 free public IPv4 per instance and SSH; you set up TLS and the firewall yourself | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Keeping keys out of the machine | Secrets stored encrypted and passed into the pod as 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 |
| Coding agents | An MCP server and skills so your own local agent can manage Runpod | An MCP server and CLI agent mode so an outside agent can manage Verda machines | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Scale to zero | Serverless workers scale to zero and start when a request arrives | Serverless containers scale to zero and start again on the next request | No wake on request; you start a stopped sandbox through the API |
| Billing step | Per second from a prepaid balance | Prepaid 10-minute blocks, unused part refunded | Per second from a monthly plan that becomes usage credit |
| Regions | 24 documented data centers in the US, Canada, Europe and Australia; says 30+ regions | EU only: three data centers in Helsinki, Finland | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Runpod | Verda | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Not published | Yes |
| Root | Yes | Yes | 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 | 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 | No | No | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | 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 | Yes | 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 | Yes | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | 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 CPU measurement for Runpod or Verda: 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 that run, on dedicated AMD Ryzen 9 9950X 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. Runpod 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 | Runpod, 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 | $26 · Pay-as-you-go (prepaid credits) · with limits | $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 | $93 · Pay-as-you-go (prepaid credits) · with limits | $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 | $1,156 · Pay-as-you-go (prepaid credits) · with limits | $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 | $307 · Pay-as-you-go (prepaid credits) · with limits | $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 | $614 · Pay-as-you-go (prepaid credits) · with limits | $507 · Pay as you go · with limits | $2,000 · $2000/mo · with limits |
Runpod: Runpod bills a running pod per second from a prepaid balance, with disk on top, and a new pod needs at least one hour of credit to start. CPU pods are not on the pricing page; the rates here come from Runpod's public CPU catalogue.
Verda: Verda charges a prepaid balance in 10-minute blocks and refunds the unused part. CPU machines cost $0.012 per vCPU-hour with 4 GB of RAM each, the disk is extra at $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
Neither Runpod nor Verda publishes how many machines can run at once, so 300 user sandboxes or 1,000 short jobs at once are not confirmed on either. Runpod limits spend instead, at $80 an hour by default, and only /workspace survives a stop, so every Runpod scenario loses packages installed elsewhere; Runpod pods also cannot run Docker, which rules them out for the 50-agent fleet. Verda's smallest CPU machine is 4 vCPU / 16 GB, so small sandboxes cost the same as medium ones, and if its balance runs out, instances stop and volumes are deleted after 96 hours.
| Scenario | Runpod | Verda | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Runpod when
you need GPUs outside Europe, the widest choice of GPU types, per-second billing or volumes shared by many pods.
- More regions. Useful if your data or users sit outside Europe: Runpod has data centers in the US, Canada, Europe and Australia.
- Wider GPU choice, billed by the second. Useful for mixed GPU work: Runpod rents dozens of Nvidia and AMD types, including MI300X, billed per second.
- Shared network volumes. Useful when many pods must read one dataset: Runpod network volumes mount on several pods at once, with an S3-compatible API.
Use Verda when
you want full VMs with root in the EU, very large CPU machines, or the cheaper CPU hours for steady work.
- Full VMs with root. Useful if your jobs need Docker or a real kernel: every Verda instance is a KVM virtual machine you fully control.
- Very large CPU machines. Useful for one huge job: Verda CPU instances go up to 360 dedicated AMD EPYC vCPU and 1,440 GB of RAM.
- Cheaper CPU hours. Useful for steady CPU work: Verda charges $0.012 per vCPU-hour with 4 GB of RAM, against $0.03 on Runpod.
Where bochka fits
Runpod and Verda are GPU clouds, and bochka has no GPUs, so training and serving models belong on one of them. If what you are really running is agents that write code, use a browser or serve previews on CPU machines, bochka gives each one a ready VM that costs nothing while stopped. Many teams keep the GPU work on Runpod or Verda and run the agents on bochka.
Docker and the whole disk, every time
A Runpod pod cannot run Docker and keeps only /workspace after a stop. Verda runs Docker, but a stopped VM keeps billing. bochka gives every sandbox Docker, /dev/kvm and a whole disk saved every minute.
Pause and fork agents freely
Agents sit idle between tasks. On Verda an idle VM bills at full rate until you delete it, and on Runpod there is no snapshot or fork. bochka stops for free and forks a running sandbox.
Agents, desktop and keys ready
Neither ships a coding agent inside the machine, a desktop or a keys proxy, so you build the runner, a VNC setup and key handling yourself. bochka preinstalls Claude Code and Codex, streams a 60fps desktop and keeps keys outside.
Use bochka when the work is agents on CPU: full VMs with Docker, a desktop, coding agents and HTTPS ports ready, whose whole disk survives a free stop. Compare it one to one: bochka vs Runpod and bochka vs Verda.
Questions people ask
Is Runpod cheaper than Verda?
For CPU work in our scenarios, Verda is cheaper: one agent running all month comes to $45 on Verda and $93 on Runpod, and 50 agents in parallel to $622 versus $1,156. For GPU eval jobs they are close, $1,001 a month on Runpod and $1,039 on Verda. On bochka the same 50 agents come to $317.
Can Runpod or Verda run Docker?
Verda can: each instance is a full VM with root, so you install Docker yourself. Runpod cannot: its docs say you cannot start your own Docker or use Docker Compose on a pod. On bochka every sandbox has Docker, Docker Compose and /dev/kvm ready.
Which is faster, Runpod or Verda?
We have no comparable CPU measurement for either, since neither is in the StarSling benchmark run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
What happens when I stop a machine?
On Runpod only /workspace is kept, billed at $0.20/GB-month while stopped, and the rest of the container disk is cleared. On Verda a shut-down instance keeps billing at its full rate until you delete it. A stopped bochka sandbox costs nothing and keeps its whole disk.
Where do Runpod and Verda run?
Runpod has data centers in the US, Canada, Europe and Australia and says it runs in 30+ regions. Verda runs only in Helsinki, Finland. bochka runs only in the EU, in Germany, Finland and France.
Is Verda the same as DataCrunch?
Yes. DataCrunch was founded in Helsinki in 2020 and became Verda in 2025. It rents GPU and CPU instances, GPU clusters and serverless containers.
Try bochka
Install the CLI, then run bochka new.
Product preview