# Runpod

Official pricing: https://www.runpod.io/pricing  
Category: gpu-cloud · Isolation: container

## Pricing regimes (raw)

- **CPU Pod, Secure Cloud, compute-optimized (cpu3c)** (sizes): cpu3c-2-4 2 vCPU/4 GiB $0.06/h; cpu3c-4-8 4 vCPU/8 GiB $0.12/h; cpu3c-8-16 8 vCPU/16 GiB $0.24/h; cpu3c-16-32 16 vCPU/32 GiB $0.48/h; cpu3c-32-64 32 vCPU/64 GiB $0.96/h; cpu3g-2-8 2 vCPU/8 GiB $0.08/h
- **GPU Pod, Secure Cloud on-demand (per GPU, vCPU/RAM bundled)** (resource): $0/vCPU-h, $0/GiB-h
- **GPU Pod, Community Cloud on-demand (peer-to-peer hosts, variable reliability)** (resource): $0/vCPU-h, $0/GiB-h [stock]
- **Serverless flex worker (GPU, scale to zero)** (resource): $0/vCPU-h, $0/GiB-h [alt]
- **Serverless CPU worker (cpu3c, API example rate)** (sizes): cpu3c-1-2 1 vCPU/2 GiB $0.036/h; cpu3g-1-4 1 vCPU/4 GiB $0.05/h; cpu3c-2-4 2 vCPU/4 GiB $0.072/h; cpu3g-2-8 2 vCPU/8 GiB $0.1/h; cpu3c-4-8 4 vCPU/8 GiB $0.144/h; cpu3g-4-16 4 vCPU/16 GiB $0.2/h [alt]
- **Instant Cluster (multi-node, per GPU, no commitment)** (resource): $0/vCPU-h, $0/GiB-h

## Features

Yes: snapshots, pause/resume, persistent disk, volumes, ≥24 h sessions, custom image (Docker or snapshot), start from your own snapshot, your own Docker/OCI image, root, code interpreter, SSH, public IPv4, HTTPS preview URLs, raw TCP inbound, open internet, private networking, SOC 2, HIPAA, SSO, GPU, Python, Node.js, wake on request, webhooks, audit logs, EU data residency, scoped API keys, spend limits, MCP server, inbound access rules, extra volumes, shared volumes

No: memory snapshots, fork/clone, idle auto-stop, full VM (own kernel), Docker inside, nested virtualization, systemd, browser, desktop GUI, computer-use API, browser + desktop control, anti-bot stealth, CAPTCHA solving, residential IPs, preinstalled agents, egress allowlist, static egress IP, self-hosting, BYOC, open source, arm64, Windows, macOS, GPU desktop, HTTP method/path egress rules, live resize, live fork (no pause), memory fork, automatic snapshots, snapshots on demand, agent harness API, hosted agent API (their own agent), gVisor or VM (no shared kernel), firewall inside (nftables), secret proxy, secret proxy for any API

Unknown: everything else. Evidence (source + quote) per feature: https://battleships.dev/data/providers/runpod.json → feature_evidence

## Caveats

- CPU prices come from Runpod's public GraphQL catalogue (api.runpod.io/graphql cpuFlavors.specifics, callable without an API key; 2026-09-29), not from the pricing page (which lists GPUs only): cpu3c pod $0.03/vCPU-h, serverless $0.036/vCPU-h. The docs API v2 example ($0.04/$0.03) is stale/illustrative. GraphQL is scheduled for retirement in early 2027; REST v2 catalog needs a key.
- cpu3c RAM is 2 GB per vCPU (GraphQL cpuFlavors ramMultiplier 2; Flash IDs cpu3c-4-8); the 2.5 GB in the API v2 docs example is not the live value.
- GPU pods: per-GPU price bundles a fixed vCPU/RAM shape per GPU type; vcpu_h/ram_gib_h encoded as 0.
- Spot/interruptible: the Cloud GPUs product page FAQ still says 'We offer spot instances ... The UI/API will indicate current spot availability and pricing', but the docs no longer describe spot and the public GraphQL catalogue returns spot/bid prices equal to on-demand for every GPU (e.g. H100 SXM securePrice 3.49 = secureSpotPrice 3.49; lowestPrice minimumBidPrice = uninterruptablePrice). No spot discount is currently obtainable in the public data; not modelled.
- Savings plans: 3- or 6-month upfront prepay for GPU compute only (storage at standard rates), non-refundable, auto-applies to next deployment of the same GPU type; discount % not published (console only). Not modelled.
- Serverless active (always-on) workers: 'discounts available through sales inquiry', rate unpublished. Reserved clusters sales-only.
- Billing granularity: pods/pricing and billing overview say per second; the docs overview page says pods are 'billed by the minute' (conflict). Charges deducted every 5 min.
- Storage: container disk $0.10/GB-mo (running only, erased on stop); volume disk $0.10 running / $0.20 stopped; network volume $0.07 (<1 TB) / $0.05 (>1 TB), high-performance $0.14; network volumes billed hourly. storage.snapshot_gib_month = stopped volume-disk rate; knob selects network-volume alternative. Not charged while host is unavailable.
- No ingress/egress fees (official). Public IP/TCP ports available on many pods; no IPv4 price published (ipv4_month null).
- features.snapshot = 'fs' (verifier 2026-09-28, was 'none'): there is no snapshot API, but a stopped pod keeps its volume disk and network volumes persist, i.e. filesystem state is retained; with 'none' the engine refused every retained-state workload even though the card prices it.
- No idle auto-stop for pods: a running pod bills until you stop it. Stopped pods may restart with zero GPUs if the host's GPUs are taken.
- At $0 balance pods stop; pods without a network volume are terminated and data is lost.
- Knob retained_state_storage (effect 'snapshot_gib_month') overrides storage.snapshot_gib_month with the stopped-volume or network-volume rate.
- Compliance (runpod.io/legal/compliance, updated 2026-09-13): SOC 2 Type II and SOC 3 completed, ISO/IEC 27001:2022 certified (valid 2026-08-27 to 2029-08-26), HIPAA and GDPR programs; documents via Trust Center. SSO/SAML not found in docs (sso stays null). No benchmark data for Runpod in this research set.
- History: the RunPod "slashes GPU prices" blog post carries conflicting dates (HTML time 2024-07-12 vs visible "Updated September 13, 2026"); its old/new tables are not treated as a confirmed September 2026 cut. Current card rates come from the live pricing page. (patch v8-history, 2026-09-28)
- Instant Clusters (fix 2026-09-28): alt flag removed and gpu_min_count 16 set (2 nodes x 8 GPUs minimum per docs), so a 1-GPU request sees it only as a "16-GPU nodes only" compromise priced at 16 GPUs.
- Community Cloud is peer-hosted with variable reliability (no SLA stated); no engine flag exists for peer/marketplace capacity, so it is priced like Secure Cloud. Engine request filed (research/verify/engine-requests.md).
- CPU pods are plain containers you provision (no sandbox API); provisioning time is unpublished (boot_overhead_s null). Not flagged alt: a CPU pod is an ordinary on-demand machine; the engine already marks gpu-cloud rows "plain VM / platform, no sandbox API" for sandbox-API personas.
- Global Volumes (beta since 2026-09-15): region-independent object-backed storage, $0.09/GB-month plus request fees (Class A writes/lists $0.005 per 1,000, Class B reads $0.0005 per 1,000); deleted 15 days after the balance hits $0. More expensive than a standard network volume ($0.07) for parked state; not modelled.
- High-performance network volume: docs say "Exact pricing varies by data center"; $0.14/GB-month is the pricing-page figure (knob option), not a guaranteed rate in every DC.
- Startup Program: Starter tier $1,000 credits (application, not automatic); Growth tier = $50,000 upfront commit + $25,000 bonus credits under a 12-month agreement (effectively a 33% discount for $50k prepay). Referral sign-ups (Google SSO, after loading $10) get a $5-$500 random bonus (EU: $5; ~96% get <= $10). None modelled as free credit.

## How this provider charges


Runpod rents Docker-container "Pods" (GPU or CPU) plus scale-to-zero Serverless workers and multi-node Clusters.
All usage comes out of a prepaid credit balance, billed per second, with **no ingress/egress fees**. There is no plan
fee. The same GPU costs a different amount depending on where it runs (Secure vs Community Cloud), how you run it
(Pod vs Serverless flex vs Cluster), and whether you prepay (savings plan). Stopped pods keep paying for disk, at
double the running rate.

Verified live 2026-09-28: runpod.io/pricing ("Updated September 27, 2026"; Community and Secure prices both
embedded in the page's schema.org Offer data), docs.runpod.io pods/pricing (modified 2026-07-20), serverless/pricing,
accounts-billing/billing, API v2 catalog reference, Flash CPU types.

## Regime table

| Regime | When it applies | How billed | Numbers | Source |
|---|---|---|---|---|
| CPU Pod (Secure Cloud) | CPU-only container pod | Per second while running, per vCPU with RAM bundled | cpu3c compute-optimized **$0.04/vCPU-h** (4 vCPU / 8 GB = $0.16/h), 2-32 vCPU. **Only source is an example payload in the API v2 catalog docs**; cpu3g (4 GB/vCPU) and cpu5c prices unpublished (console / authenticated API only) | https://docs.runpod.io/api-reference-v2/catalog/list-cpu-types, https://docs.runpod.io/flash/configuration/cpu-types |
| GPU Pod, Secure Cloud on-demand | GPU pod in T3/T4 DCs; the only option for Organizations / post-paid | Per second per GPU; per-GPU vCPU/RAM shape bundled | B300 $7.89, B200 $6.79, H200 $4.59, H100 SXM $3.49, H100 NVL $3.19, H100 PCIe $2.89, RTX PRO 6000 $2.09, A100 80GB SXM/PCIe $1.59, L40S $1.09, MIG 48GB $1.09, 6000 Ada $0.84, L40 $0.82, A6000 $0.53, A40 $0.49, 5090 $0.99, 4090 $0.74, MIG 24GB $0.59, 3090 $0.50, L4 $0.49, A5000 $0.27 per GPU-h | https://www.runpod.io/pricing |
| GPU Pod, Community Cloud on-demand | Peer-hosted GPUs; variable reliability; not for Organizations | Same, cheaper; not interruptible | B300 $6.94, B200 $5.98, H200 $3.59, H100 SXM $2.69, H100 NVL $2.59, H100 PCIe $1.99, PRO 6000 $1.69, A100 SXM $1.39 / PCIe $1.19, L40S $0.79, 6000 Ada $0.74, L40 $0.69, A6000 $0.33, A40 $0.35, 5090 $0.69, 4090 $0.34, 3090 $0.22, L4 $0.44, A5000 $0.16. Runpod no longer accepts new Community hosts | https://www.runpod.io/pricing (embedded Offer data), https://docs.runpod.io/pods/choose-a-pod |
| Savings plan | GPU pods, long-running | 3- or 6-month **upfront** prepay; GPU compute only (storage at standard rates); non-refundable; fixed expiry; auto-applies to next deploy of same GPU type | Discount % **not published** (console only) | https://docs.runpod.io/pods/pricing |
| Spot / interruptible | — | Not mentioned anywhere in current docs (llms-full.txt) or pricing page; older records and third-party blogs still describe it | null (possibly discontinued) | https://docs.runpod.io/llms-full.txt |
| Serverless flex workers (GPU) | Request/queue endpoints, scale to zero | Per second, rounded up, from worker start to full stop: cold start + execution + idle timeout (default 5 s) | per GPU class: B300 $9.98, B200 $8.64, H200 $5.93, H100 $4.79, RTX 6000 Pro $3.49, A100 $2.72, 48GB PRO $1.75, A6000/A40 $1.22, 5090 $1.58, PRO 4500 $1.15, 4090 $1.10, 24GB $0.69, 16GB $0.58 per h | https://www.runpod.io/pricing, https://docs.runpod.io/serverless/pricing |
| Serverless active workers | Always-on (24/7) workers | Always billed; discount "through sales inquiry" | null | https://docs.runpod.io/serverless/pricing |
| Serverless CPU workers / Flash CPU | CPU endpoints | Same as flex | $0.03/vCPU-h cpu3c (**API example payload only**) | https://docs.runpod.io/api-reference-v2/catalog/list-cpu-types |
| Instant Clusters | Multi-node, up to 64 GPUs self-serve | Per GPU-h, no commitment | H200 SXM $4.31, A100 SXM $1.79; L40S / H100 SXM / B200 contact sales | https://www.runpod.io/pricing |
| Reserved Clusters | 1/3/6/12/12+ month terms, SLA | Sales contract | contact sales | https://www.runpod.io/pricing |
| Enterprise post-paid (Organizations) | Contracted customers | Invoiced in arrears at contracted rates; Secure Cloud only; no $0 auto-stop | null | https://docs.runpod.io/accounts-billing/post-paid-billing |
| Container disk | Every pod / worker | Per second while running; erased on stop, not billed when stopped | $0.10/GB-month (serverless: ~$0.10, 5-min intervals) | https://docs.runpod.io/pods/pricing |
| Volume disk | Pod-attached persistent disk | Per second; **doubles when pod is stopped** | $0.10 running / **$0.20 stopped** per GB-month | https://docs.runpod.io/pods/pricing |
| Network volume | Portable, shared across pods/serverless | Hourly, whether attached or not | $0.07/GB-mo < 1 TB, $0.05 > 1 TB; high-performance $0.14 | https://docs.runpod.io/pods/pricing, https://www.runpod.io/pricing |
| Data transfer | All | Free | $0 ingress / $0 egress | https://docs.runpod.io/accounts-billing/billing |
| Account limits | Prepaid accounts | $80/hour default spend limit (auto-raised with history); deploy needs ≥ 1 h credit for the config; start from ~$10 | — | https://docs.runpod.io/accounts-billing/billing |

## Gotchas

1. **CPU pod pricing is effectively unpublished.** The only official number ($0.04/vCPU-h) is an API example payload;
   the pricing page lists GPUs only. RAM/vCPU for cpu3c also conflicts (2.5 GB in the example vs 2 GB in Flash IDs).
2. **Stopped pods cost more per GB.** Volume disk goes from $0.10 to $0.20/GB-month when stopped; container disk is
   wiped on stop. Network volumes ($0.07) are cheaper for parked state and survive balance exhaustion.
3. **$0 balance = data loss.** Pods auto-stop at $0; pods without a network volume are terminated unrecoverably.
   Network volumes can also be terminated if charges stay uncovered.
4. **No idle auto-stop for pods.** A pod bills until you stop it; there is no activity-based shutdown.
5. **Stopped GPU pods may restart with zero GPUs** if the host's GPUs were taken meanwhile (docs "Zero GPU Pods").
6. **Serverless bills cold start and idle timeout**, not just execution; per-class serverless rates are 25-100%+ above
   the pod rate for the same GPU (e.g. H100 $4.79 serverless vs $3.49 Secure pod vs $2.69 Community).
7. **Community Cloud is shrinking** (no new hosts) and unavailable to Organizations, so the cheapest GPU prices may
   not be obtainable at scale or for enterprise accounts.
8. **Spot is gone from the docs**; older comparisons quoting spot prices are stale.
9. **Granularity conflict**: pricing/billing docs say per second, the docs overview says pods are "billed by the minute".
10. **Savings plans** lock GPU type and are non-refundable; discount only visible in the console.

## Worked example

Workload: 4 vCPU / 8 GiB, 50 concurrent × 8 h/day × 22 days = **8,800 pod-hours**, 30% CPU, 50 GiB retained
state, 100 GiB egress. CPU pods (no GPU). Pods stopped between shifts.

Compute: 8,800 × $0.16 = **$1,408.00** (cpu3c 4 vCPU @ $0.04, RAM bundled; utilisation irrelevant, allocated billing).
Retained 50 GiB: on stopped-pod volume disk 50 × $0.20 = $10.00; on a network volume 50 × $0.07 = $3.50.
Egress: $0.

| Regime | Feasible? | Monthly total |
|---|---|---|
| CPU Pod, Secure, state on stopped volume disk | Yes (spend limit $80/h vs 50 × $0.16 = $8/h) | **$1,418.00** (+ running container/volume disk at $0.10/GB-mo) |
| CPU Pod, state on network volume | Yes | **$1,411.50** |
| Serverless CPU worker (cpu3c-4-8 @ $0.12/h) | Only for request/queue work, not interactive sessions; no SSH | ≈ $1,056 + cold-start/idle overhead (rate from API example only) |
| Savings plan | No: GPU compute only | n/a |
| Anti-pattern: pods left running 24/7 | Yes | 50 × 730 × $0.16 = **$5,840** |
| GPU variant (same schedule, 1× H100 SXM each) | Yes | Secure 8,800 × $3.49 = $30,712; Community 8,800 × $2.69 = $23,672; serverless flex 8,800 × $4.79 = $42,152 (+ overhead) |