Runpod Pricing Explained: Pods vs Serverless, With a Break-Even Calculator

Runpod pricing has two main models. Pods are dedicated GPU machines billed per second for as long as they run, from about $0.59 an hour for an A40 to $3.99 an hour for an H100 SXM on Runpod’s pricing page. Serverless workers are billed per second only while they start, process requests and wait out a short idle timeout, at higher hourly rates, such as $1.10 an hour for an RTX 4090 and $4.79 for an H100. Pods are cheaper per hour; Serverless is cheaper when your GPU would otherwise sit idle. Using Runpod’s list prices, Serverless stays cheaper until a GPU is busy roughly 12 to 20 hours a day, depending on the GPU. There are no fees for data ingress or egress, but storage keeps charging on stopped Pods.

Disclosure: some links in this article may be affiliate or referral links. If you sign up through them, scientyficworld.org may earn a commission or credits at no extra cost to you. It does not change our recommendations.

Prices were taken from Runpod’s pricing page and billing rules from its Pods and Serverless documentation on 12 October 2026. Runpod shows one headline price per GPU on its pricing cards, but rates also vary between its Secure Cloud and Community Cloud, so check the console when you deploy.

Pods vs Serverless: How Each Is Billed

	Pods	Serverless
What you get	A dedicated GPU machine you control	Workers that start on demand to process requests
Billing unit	Per second while the Pod runs	Per second from worker start until it fully stops
Idle time	Billed: a running but idle Pod still costs money	Only the idle timeout (default 5 seconds) after each request
Scales to zero	No; you stop the Pod yourself	Yes, with flex workers
Discounts	Savings plans: prepaid 3 or 6 months (GPU compute only)	Active (always-on) workers: discounts through sales
Best for	Training, long jobs, steady traffic, interactive work	Bursty or unpredictable inference traffic

For Serverless, Runpod bills start time (mostly loading your model into GPU memory), execution time and the idle timeout. Pulling the container image is not billed. Model caching and FlashBoot reduce start time, which matters because slow cold starts are paid time.

GPU Prices: Pods and Serverless

GPU	Pod ($/hour, pricing card)	Serverless ($/hour)
H100 SXM	$3.99	$4.79 (H100 80GB)
H100 PCIe	$2.89	$4.79 (H100 80GB)
A100 80GB	$1.79	$2.72
L40S	$1.09	$1.75
RTX 5090	$1.19	$1.58
RTX 4090	$0.89	$1.10
A40	$0.59	$1.22

Community Cloud Pods are listed for less than these card prices on several GPUs (for example, an RTX 4090 from $0.34 an hour and an H100 PCIe from $1.99 in Runpod’s published price data). Runpod offers Pods in two environments, Secure Cloud and Community Cloud, at different prices, so choose the one that fits your data and reliability requirements.

Break-Even: When Serverless Beats a Pod

The question that decides most bills is how many hours a day your GPU does useful work. A Pod costs its hourly rate for every hour it is running. Serverless costs its higher rate only for billed seconds. Divide the Pod price by the Serverless price and you get the share of the day your GPU must be busy before a Pod becomes cheaper:

GPU	Break-even (busy hours per day)	Share of the day
H100 SXM	20.0	83%
RTX 4090	19.4	81%
RTX 5090	18.1	75%
A100 80GB	15.8	66%
L40S	14.9	62%
H100 PCIe	14.5	60%
A40	11.6	48%

For example, an RTX 4090 Pod left running all month costs about $641. On Serverless, the same GPU busy 2 hours a day costs about $66 a month, 8 hours a day about $264, and 16 hours a day about $528. Above about 19 busy hours a day, the Pod wins.

Remember that “busy” for Serverless includes cold starts and the idle timeout, not just request processing. If your workers spend a lot of time loading a large model, your billed hours are higher than your request time. Here is the calculator used above; replace the prices with current ones and your own busy hours:

# Runpod list prices (USD per hour) from runpod.io/pricing, checked 12 Oct 2026. Edit to current rates.
POD = {"H100 SXM": 3.99, "H100 PCIe": 2.89, "A100 80GB": 1.79, "L40S": 1.09, "RTX 4090": 0.89, "RTX 5090": 1.19, "A40": 0.59}
SERVERLESS = {"H100 SXM": 4.79, "H100 PCIe": 4.79, "A100 80GB": 2.72, "L40S": 1.75, "RTX 4090": 1.10, "RTX 5090": 1.58, "A40": 1.22}

def monthly(gpu, busy_hours_per_day, days=30):
    """Pod bills every hour it runs; Serverless bills only billed seconds (start + execution + idle timeout)."""
    pod = POD[gpu] * 24 * days
    serverless = SERVERLESS[gpu] * busy_hours_per_day * days
    return pod, serverless

def break_even_hours(gpu):
    return 24 * POD[gpu] / SERVERLESS[gpu]

for g in POD:
    print(f"{g:10} pod ${POD[g]:.2f}/h  serverless ${SERVERLESS[g]:.2f}/h  break-even {break_even_hours(g):.1f} busy h/day ({POD[g]/SERVERLESS[g]:.0%})")
for h in (2, 8, 16):
    pod, sl = monthly("RTX 4090", h)
    print(f"RTX 4090, {h} busy h/day: pod ${pod:.0f}/mo vs serverless ${sl:.0f}/mo")

Storage and Other Costs

Item	Price	Note
Container disk	$0.10/GB/month	Erased when a Pod stops
Volume disk, running Pod	$0.10/GB/month	Kept until the Pod is deleted
Volume disk, stopped Pod	$0.20/GB/month	Twice the running rate
Network volume	$0.07/GB/month under 1 TB; $0.05 over 1 TB	Charged whether or not anything uses it
Data ingress and egress	Free	Runpod charges no transfer fees

Other rules worth knowing: you need at least one hour of credits to deploy a Pod; the default spending limit is $80 an hour across all resources; and when your balance reaches zero, Pods stop, and Pods without a network volume are terminated with their data. Runpod also says it is not designed for long-term storage, so back up anything important.

How to Keep Runpod Costs Down

• Use Serverless for spiky inference and Pods for training or steady load; check the break-even table for your GPU.
• Stop Pods you are not using, and delete volumes you no longer need, because stopped volume disks cost twice as much.
• Cut Serverless cold starts with model caching and FlashBoot, since start time is billed.
• Consider Community Cloud for experiments, and savings plans if you will run the same GPU for three or six months.

Comparing providers? See Runpod vs Vast.ai and Runpod vs Lambda. If you are running open models locally instead, our guide to running local LLMs with Ollama and n8n covers the self-hosted route.

To check today’s prices for the GPU you need, create a Runpod account and compare Pod and Serverless rates in the console before you deploy.

Conclusion

Runpod’s pricing is straightforward once you separate the two models. Pods charge for every second they run; Serverless charges for every second a worker is alive, at a higher rate. Estimate how many hours a day your GPU is really busy, compare it with the break-even for your GPU, and budget for storage separately. Transfer is free, so storage and idle time are what usually surprise people.