RunPod

Runpod rents GPUs by the second, either as pods you control or as serverless endpoints. On 31 October 2026 an H100 SXM was $2.69 an hour on Community Cloud and $3.99 on Secure Cloud, and an RTX 4090 was $0.34 and $0.89. It suits steady GPU work and custom models. It is a poor fit if you only need a few million tokens a month.

Some links on this page go through /go/ and may earn us a fee; it never changes our order. The brand is spelled Runpod.

Facts at a glance

For a three-way view with the other GPU clouds, see Runpod vs Lambda, Modal vs Runpod and Runpod vs Vast.ai. The interactive hosting compare filters by GPU, price and region.

What Runpod sells

Runpod's pricing page groups its products by the kind of workload.

Pods are dedicated GPU instances for development and long-running jobs. You pick a GPU, an image and storage, and the pod is yours until you stop it. This is the product behind the hourly numbers above.

Serverless bills inference workers by usage. You package a handler, set a minimum and maximum worker count, and requests spin workers up and down. The docs describe two worker types: flex workers, which scale to zero and bill only while running, and active workers, which stay on and cost less per second in exchange for always being billed.

Clusters are multi-node setups that the page says scale up to 64 GPUs with shared storage and no commitments, and it also lists reservations through sales.

Runpod Hub is a catalogue of ready-made templates and endpoints. The pricing page also lists per-request and per-token rates for hosted models. We do not cover those, since the page mixes many models and units.

The prices

Prices checked on 31 October 2026 on runpod.io/pricing, in dollars per hour:

On Secure Cloud only, the page also lists the H100 PCIe at $2.89, the H100 NVL at $3.19, the L40S at $1.09, the RTX 6000 Ada at $0.99, the A40 at $0.59 and the RTX 5090 at $1.19. In a plain fetch the page rendered a single rate for several cards, so confirm the tier on the page before you budget.

Storage is separate. Container disk is billed at about $0.10 per GB a month for worker storage, per the Serverless docs. Network volumes, which persist and move between pods, are $0.07 per GB a month under 1 TB and $0.05 over, and a high-performance volume is $0.14. The pricing page also lists a pod volume rate of $0.10 per GB a month while running and $0.20 while idle. Remember that a stopped pod's disk can still be billed.

What you pay in practice

The volumes below are examples we chose. Replace them with your own.

Example one: fine-tuning for a weekend. You run an H100 SXM for 20 hours. Community: 20 × $2.69 = $53.80. Secure: 20 × $3.99 = $79.80. Add a 100 GB network volume for the month at $0.07 per GB, which is $7.00. The total is about $61 to $87.

Example two: an always-on 80 GB inference pod for a team. An A100 on Secure at $1.79 an hour for a 720-hour month is about $1,289. If it runs only 10 hours a day on 22 working days, 220 hours, it is about $394. The difference is whether you remember to stop it. A schedule or a script that stops idle pods pays for itself.

Example three: occasional experiments. An RTX 4090 on Community at $0.34 an hour for 15 hours in a month is $5.10. On Secure at $0.89 it is $13.35.

Example four: bursty serverless inference. A worker on an H100 billed per second: if each request takes 4 seconds of GPU time and you serve 50,000 requests a month, that is 200,000 seconds, or about 55.6 hours of GPU time. At an hourly rate of $3.99 that would be about $222 if the rate for your worker type matched the pod rate, which it may not. Add cold-start time, which the docs say comes from the worker starting until the handler is ready, mostly model loading. Runpod does not bill the container image pull while the worker is scaled down. A worker waits for new requests for an idle timeout, 5 seconds by default, before scaling down.

For comparison, a per-token API serving gpt-oss-120b on Groq at $0.15 and $0.60 per million tokens would cost cents for the same number of short requests. GPUs pay off when you need a model the APIs do not host, or when volume is high and steady.

Community Cloud versus Secure Cloud

The tier choice is the biggest lever on both price and risk.

The docs add that Runpod's pods and workers run in a multi-tenant environment, with each in its own container and strict separation from other workloads. For anything sensitive, we would use Secure Cloud and read Runpod's data terms first.

Limits and gotchas

• Spend limit. The default is $80 an hour across all resources. A cluster of large GPUs can hit it, and support can raise it.
• Cold starts on Serverless. The time from worker start to ready handler is yours to minimise, with FlashBoot or model caching, per the docs.
• Idle pods still bill. A pod bills while it runs, not while it is busy.
• Blackwell MIG slices. RTX PRO 6000 MIG slices are Secure-only and use Blackwell, so check CUDA and framework versions first.
• Marketplace variance. Community capacity varies by host, so test your workload and keep checkpoints on a network volume.
• Region choice. GDPR statements apply to European regions, so pin a region if that matters.

Picking a GPU on Runpod

The right card depends on the model, so size the model first. Listed sizes from Ollama's library: gpt-oss 20B is 14 GB, Qwen3-Coder 30B is 19 GB, Llama 3.3 70B is 43 GB and gpt-oss 120B is 65 GB. Add about a quarter for the cache.

Two points stand out. The L40S at $1.09 holds 48 GB, so it is the cheapest way on this list to run a 70B model quantised. And an A100 holds the same 80 GB as an H100 for less money, so pick the H100 for speed and not for capacity. Our GPU requirements for LLMs page covers the sums in detail.

A first serverless endpoint

The Serverless docs describe the lifecycle you will be paying for, which is the part most people skip.

1. Cold start. A worker starts, loads the model into GPU memory and readies the handler. This time is billed.
2. Active. The worker processes a job. Billed.
3. Waiting. After the last job, the worker waits for the idle timeout, 5 seconds by default, in case another arrives. Billed.
4. Scaled down. The worker is shown as idle in the console. Not billed.

From that, three tuning rules follow. Keep the model small or cached, so the cold start is short. Set the idle timeout long enough to catch bursts and short enough not to pay for silence. And set an active worker count above zero only if the saving from avoiding cold starts exceeds the cost of always-on workers. Flex workers are cheaper when traffic is thin, and active workers are cheaper per second for steady traffic.

Controlling spend

GPU bills surprise people through forgotten pods and runaway loops. A few habits help.

• Stop pods when done. Make it the last step in your script.
• Use the spend limit. Runpod's default of $80 an hour is high for a small account, and you can ask support about limits that match your budget.
• Prefer a network volume over keeping a pod on. Storage at $0.07 per GB a month is cheaper than holding a GPU idle.
• Test on a small card. Debug on a $0.34 RTX 4090 and move to an H100 for the real run.
• Check the bill weekly. Costs are per second, so an error shows up fast.

Moving in and out

You can leave Runpod without much loss if you plan for it. Containers are standard Docker images, so the same image runs on another GPU cloud. Keep model weights on a network volume or in object storage you control, and keep scripts in git. If you serve with vLLM or Ollama, the OpenAI-compatible API means client code keeps working when you change the base URL. When you compare moving to Lambda, check that a filesystem there must sit in the same region as the instance, and that Lambda's page lists no egress fees. Compare with Lambda Cloud.

Who should pick Runpod

Alternatives

• Lambda Cloud: on-demand GPUs at fixed list prices, 1x H100 SXM at $4.29 an hour.
• Modal: serverless Python functions with per-second GPU billing and $30 a month of Starter credit.
• Replicate: run public models by the second or token without managing servers.
• Hugging Face Inference: dedicated endpoints, A100 80 GB at $2.50 an hour on AWS.
• Cloudflare Workers AI: per-token models, no GPU to manage.
• AI hosting overview for the full map.

Getting started

1. Make an account and add credit. A small test costs under a dollar.
2. Create a network volume in the region you want, so models survive pod restarts.
3. Deploy a pod with a template such as a vLLM or Ollama image. See vLLM and Ollama.
4. Expose the port through the proxy Runpod provides, and set an API key on the server.
5. Download your model, run a test prompt and record tokens and time.
6. Stop the pod when finished. Delete what you no longer need.

For sizing the card, see GPU requirements for LLMs.

Our take

Runpod's strength is range: from a $0.34 RTX 4090 to an $8.99 B300, billed per second, with a serverless option. The Community and Secure split is the key decision. Use Community for experiments, Secure for anything you would mind losing. It is a poor choice when per-token pricing would do. Compare at least one per-token API before you rent a GPU. These notes come from Runpod's pricing page and docs, and we did not benchmark it.

Related pages

• Hosting hub and AI hosting overview
• Private AI hub
• How to self-host an LLM