# What are the best Beam Cloud alternatives for serverless GPUs?

> Beam Cloud alternatives for serverless GPUs: Nodus, Modal, RunPod Serverless, Baseten and Cerebrium compared on one 24 GB endpoint at list prices.

Source: https://www.nodus-compute.ai/blog/beam-cloud-alternatives/
Build revision: 3c02e1544ebe4a13433d00e90a9a5396c6895ba6

<!-- vale Nodus.Providers = NO -->

The best Beam Cloud alternatives for serverless GPUs are Nodus, Modal, RunPod Serverless, Baseten and Cerebrium, and the cheapest depends on your GPU and how much CPU and memory your handler needs. Nodus lists the NVIDIA RTX 4090 at $0.290 per hour, so 100 busy hours cost $29.00 there, against $176.57 on Beam’s serverless RTX 4090 with 4 vCPU and 16 GiB. Beam stays the better pick for HTTP endpoints on your own code, lower-priced whole H100 and H200 machines, and running in your own cloud account.

We build Nodus, so read this with that in mind. Every fact about another company links to its own pricing page or docs, and every cost is written out so you can redo it with today’s prices.

## What does Beam’s serverless GPU actually cost?

Beam’s serverless GPU line is short, and CPU and memory are billed on top of it. Its [pricing page](https://www.beam.cloud/pricing.md) lists two serverless GPUs. The NVIDIA RTX 4090 24 GB is $0.69 per hour and starts right away; the RTX 5090 32 GB is $1.09 per hour with committed spend. Billing is by the millisecond while your code runs.

The part people miss is the attached CPU and memory. Beam charges $0.18972 per vCPU-hour and $0.0198 per GiB-hour for CPU and RAM attached to a GPU, the same on every tier. Its own example, an RTX 4090 endpoint with 4 vCPU and 16 GiB, comes to $1.77 per hour: $0.69 for the GPU, $0.76 for CPU and $0.32 for RAM.

Beam’s [GPU docs](https://docs.beam.cloud/v2/environment/gpu.md) add that GPU names the SDK accepts are “not a promise that every model is currently available serverless”, and point you to `beam machine list` for live availability. Bigger cards such as the H100, H200 and B200 appear on Beam as on-demand machines priced per machine, not as serverless GPUs.

## How do the main Beam alternatives compare?

The alternatives split by what they bill and what a 24 GB card costs per busy hour. This table uses each platform’s cheapest listed 24 GB option.

|Platform|24 GB option|Listed rate|CPU and RAM|Billing unit|
|-|-|-|-|-|
|Beam|RTX 4090|$0.69/hr GPU|Extra: $0.18972/vCPU-hr, $0.0198/GiB-hr|Millisecond|
|Nodus|RTX 4090|$0.290/hr|Offering rate covers the whole machine|Live quote, frozen at start|
|RunPod Serverless (flex)|L4, A5000, 3090|$0.75/hr|Included|Second, rounded up|
|RunPod Serverless (flex)|RTX 4090 PRO|$1.34/hr|Included|Second, rounded up|
|Baseten|L4|$0.01414/min|Per instance|Minute|
|Cerebrium|L4, 2 vCPU, 10 GB|$0.000257/s|Included in that example|Second|
|Modal|L4|$0.000222/s GPU|Extra: $0.0000131/core-s, $0.00000222/GiB-s|Second|

Prices checked November 21, 2026: [Beam pricing](https://www.beam.cloud/pricing.md), [Nodus pricing](https://www.nodus-compute.ai/pricing/), [RunPod pricing](https://www.runpod.io/pricing) and [RunPod Serverless billing](https://docs.runpod.io/serverless/pricing), [Baseten pricing](https://www.baseten.co/pricing/), [Cerebrium pricing](https://www.cerebrium.ai/pricing) and [Modal pricing](https://modal.com/pricing). Nodus rented rates are live quotes that are frozen when capacity is acquired, and an offering’s hourly rate applies to the whole machine, per the [usage and costs guide](https://www.nodus-compute.ai/docs/guides/billing/usage-and-costs/). Modal counts one physical core as 2 vCPU.

Replicate is the other common name here. Its [pricing page](https://replicate.com/pricing) bills per second, but it lists no 24 GB card: its GPUs start with an NVIDIA T4 16 GB at $0.81 per hour and an L40S at $3.51.

## What does the same endpoint cost on each platform?

We priced one workload everywhere: an inference endpoint on a 24 GB GPU that is busy 100 hours a month, or 360,000 GPU-seconds. Where CPU and memory are billed separately, we used Beam’s own example of 4 vCPU and 16 GiB. Idle time, storage and egress are left out, and these are list prices.

|Platform and configuration|Per busy hour|100 busy hours|
|-|-|-|
|Nodus, RTX 4090|$0.290|$29.00|
|RunPod Serverless flex, 24 GB tier|$0.75|$75.00|
|Baseten, L4|$0.8484|$84.84|
|Cerebrium, L4 with 2 vCPU and 10 GB|$0.9252|$92.52|
|Modal, L4 with 2 cores (4 vCPU) and 16 GiB|$1.0214|$102.14|
|RunPod Serverless flex, RTX 4090 PRO|$1.34|$134.00|
|Beam, RTX 4090 with 4 vCPU and 16 GiB|$1.7657|$176.57|

Same sources and check date as above. Baseten is $0.01414 x 6,000 minutes, and Cerebrium is $0.000257 x 360,000 seconds. Modal is ($0.000222 + 2 x $0.0000131 + 16 x $0.00000222) x 360,000 = $102.14. Beam is ($0.69 + 4 x $0.18972 + 16 x $0.0198) x 100 = $176.57, which Beam rounds to $1.77 per hour.

![Cost of 100 busy hours on a 24 GB GPU at list prices on November 21, 2026: Nodus RTX 4090 $29.00, RunPod Serverless 24 GB tier $75.00, Baseten L4 $84.84, Cerebrium L4 $92.52, Modal L4 $102.14, RunPod Serverless RTX 4090 PRO $134.00 and Beam RTX 4090 with 4 vCPU and 16 GiB $176.57.](https://www.nodus-compute.ai/blog-charts/beam-cloud-alternatives/busy-hours.svg) *For the same 100 busy hours, Nodus is $147.57 cheaper than Beam’s RTX 4090 with 4 vCPU and 16 GiB.*

Two caveats keep this fair. The L4 is a slower card than the RTX 4090, so a model that needs the 4090’s speed takes more busy hours on an L4. And the Nodus, RunPod and Baseten rates cover whatever CPU and memory the offering comes with, which is not exactly 4 vCPU and 16 GiB.

## Why is Beam’s GPU price low but its endpoint price high?

Because CPU and memory attached to a Beam GPU cost more than the GPU in a 4 vCPU, 16 GiB setup. In the example above, 100 hours is $69.00 of GPU, $75.89 of CPU and $31.68 of RAM. If your handler fits in 1 vCPU and 4 GiB, the same 100 hours on Beam is $69.00 + $18.97 + $7.92 = $95.89.

![Beam RTX 4090 cost for 100 busy hours at list prices on November 21, 2026: with 4 vCPU and 16 GiB it is $69.00 GPU, $75.89 CPU and $31.68 RAM, $176.57 in total; with 1 vCPU and 4 GiB it is $69.00 GPU, $18.97 CPU and $7.92 RAM, $95.89 in total.](https://www.nodus-compute.ai/blog-charts/beam-cloud-alternatives/beam-breakdown.svg) *Trimming CPU and memory nearly halves a Beam endpoint bill, so size them before you compare platforms.*

So before you move anything, check what your handler requests. Our [what is a serverless GPU guide](https://www.nodus-compute.ai/blog/what-is-serverless-gpu/) explains which parts of a serverless bill grow with traffic.

## Which Beam alternative handles cold starts best?

All of them lose time loading weights onto a fresh GPU; they differ in what they bill for it. Beam’s [pricing FAQ](https://www.beam.cloud/pricing.md) says it does not charge for spinning up a server or loading your container image, only for loading your application code. Its [cold start docs](https://docs.beam.cloud/v2/topics/cold-start.md) describe `checkpoint_enabled=True` for capturing initialized state, with support depending on the runtime.

RunPod bills a Serverless worker from start until it stops, including model loading, but not image pulls or cached model downloads, per its [billing docs](https://docs.runpod.io/serverless/pricing). Cerebrium’s [pricing page](https://www.cerebrium.ai/pricing) says its containers scale up and down in 1 to 3 seconds and that memory and GPU snapshotting can restore workloads faster.

On Nodus, GPU snapshots are in Beta. In the [GPU snapshots guide](https://www.nodus-compute.ai/docs/guides/functions/gpu-snapshots/), a vLLM worker serving Qwen3-0.6B on an NVIDIA A10 answered 16.3 to 17.0 seconds after starting from a snapshot. A cold start took 91.5 to 95.5 seconds. Nodus publishes no fixed cold-start figure, so test your own model if first-request latency matters. Our [best serverless GPU platforms guide](https://www.nodus-compute.ai/blog/best-serverless-gpu-platforms-2026/) compares this across more platforms.

## How do keep-warm settings change the bill?

A warm worker turns any serverless endpoint into an always-on bill. Beam’s [keep-warm docs](https://docs.beam.cloud/v2/endpoint/keep-warm.md) say `keep_warm_seconds` is billable and `min_containers=1` runs a container 24/7. On Nodus, `min_workers` defaults to 0 and `scaledown_window` to 1 minute, up to 20, per the [scaling guide](https://www.nodus-compute.ai/docs/guides/functions/scaling/).

The math is simple: one warm worker for a 730-hour month costs 730 times the busy-hour rate. That is 730 x $1.7657 = $1,288.96 for the Beam configuration above, and 730 x $0.290 = $211.70 for an RTX 4090 on Nodus. For a worker that is warm all month, the hourly rate matters far more than millisecond billing.

One gap to know: a Nodus Function does not take a spend cap yet. The [Function spending controls](https://www.nodus-compute.ai/docs/guides/functions/billing/) say `max_cost` is refused at deploy and your credit balance is the limit, though project [budgets](https://www.nodus-compute.ai/docs/guides/billing/budgets/) still apply.

## Where is Beam the better choice?

Beam wins in specific cases, and for some teams they outweigh the endpoint price.

It is better for public HTTP endpoints on your own code. A Beam `@endpoint` deploys as a web API, per its [quickstart](https://docs.beam.cloud/v2/getting-started/quickstart.md). Nodus Functions are called from Python with `.remote()`, `.map()` or `.spawn()`, and the base-URL endpoints Nodus offers today are for catalog models through [Inference (Beta)](https://www.nodus-compute.ai/docs/guides/inference/).

It is cheaper for whole on-demand machines with the newest GPUs. Beam’s [pricing page](https://www.beam.cloud/pricing.md) lists one flat price per machine, including CPU, RAM and NVMe: an H100 PCIe from $1.83 per hour, an H200 from $2.09 and a B200 from $4.11. Nodus lists the H100 SXM at $2.600, the H200 at $3.593 and the B200 at $5.500. Nodus is lower on the A100 80GB ($1.090 against $1.36) and the RTX 4090 ($0.290 against $0.44), and the L40S is close ($0.793 against $0.76).

![On-demand hourly rates on November 21, 2026, Beam against Nodus: H100 $1.83 against $2.600, H200 $2.09 against $3.593, B200 $4.11 against $5.500, A100 80GB $1.36 against $1.090 and L40S $0.76 against $0.793.](https://www.nodus-compute.ai/blog-charts/beam-cloud-alternatives/on-demand-rates.svg) *For a whole H100, H200 or B200 machine, Beam’s starting price is lower than Nodus; for the A100 and RTX 4090, Nodus is lower.*

Beam’s own example puts 8 hours on an H100 machine at $14.64. The same 8 hours is $20.80 on a Nodus H100 SXM and $0.001097 x 28,800 seconds = $31.59 on Modal. Beam’s H100 is a PCIe card, so check that your job does not need SXM.

It also runs in your own cloud. Beam’s [bring-your-own-cloud option](https://www.beam.cloud/pricing.md) manages work in your AWS, GCP or Azure account. The fee is $0.019 per vCPU-hour and $0.009 per GB-hour, or $0.44 per hour on an 8 vCPU, 32 GB `g5.2xlarge`. Beam charges no egress fees and offers a self-hosted product.

Finally, Beam puts VMs that pause with memory intact, sandboxes and serverless GPUs behind one CLI with an MCP server for coding agents, per its [introduction](https://docs.beam.cloud/v2/getting-started/introduction.md). If you live in that agent dev-box workflow, switching may cost more than an endpoint saves.

Beam is not one of the cloud accounts you can connect to Nodus. The supported providers are listed in the [cloud accounts guide](https://www.nodus-compute.ai/docs/guides/pools/cloud-accounts/).

## Which Beam alternative should you pick?

Pick by the busy-hour price of your exact configuration, including CPU and memory, and then by how the endpoint is called.

* Your handler runs on a 24 GB card, traffic is bursty, and your backend calls it from Python: Nodus. In our example it was $29.00 for 100 busy hours, and an idle worker leaves after its `scaledown_window`.
* You need an HTTP endpoint with serverless GPUs from 16 GB to 288 GB and per-second billing: [RunPod Serverless](https://www.runpod.io/pricing). Our [RunPod alternatives guide](https://www.nodus-compute.ai/blog/runpod-alternatives-2026/) covers its other products.
* You want Python-defined functions with monthly free credits: Modal. Its Starter plan includes $30 a month of [free credits](https://modal.com/pricing). Our [Modal alternatives guide](https://www.nodus-compute.ai/blog/modal-alternatives-for-training-2026/) covers the training side.
* You want dedicated model deployments billed per minute: [Baseten](https://www.baseten.co/pricing/). Fast scaling with GPU snapshotting: [Cerebrium](https://www.cerebrium.ai/pricing).
* You run long fine-tunes rather than endpoints: see [serverless GPUs for training](https://www.nodus-compute.ai/blog/serverless-gpu-for-training/) before choosing any endpoint platform.
* You need an HTTP endpoint on your own code, whole H100 or B200 machines, or work inside your own AWS, GCP or Azure account: stay on Beam.

We wrote that rule from the worked examples above. Redo the busy-hour math with your real CPU and memory before deciding.

## How do you move a Beam endpoint to Nodus?

Map Beam’s `on_start` loader to a Nodus `@nodus.enter()` method and its `keep_warm_seconds` to `scaledown_window`. Install the SDK and sign in:

Terminal window

```sh
pip install nodus-compute
nodus login
```

Then define a class whose model loads once per worker. The decorator arguments come from the [Functions and classes guide](https://www.nodus-compute.ai/docs/guides/python/functions/) and the [scaling guide](https://www.nodus-compute.ai/docs/guides/functions/scaling/); `load_model()` stands in for your own loader:

```python
import nodus

app = nodus.App("classifier")


@app.cls(gpu="RTX 4090", min_workers=0, max_workers=10, scaledown_window="5m")
class Model:
    @nodus.enter()
    def load(self) -> None:
        self.model = load_model()

    @nodus.method()
    def predict(self, text: str) -> dict:
        return self.model(text)
```

Deploy it with `nodus deploy app.py`. With `min_workers=0` it scales to zero when idle, and `scaledown_window="5m"` matches Beam’s `keep_warm_seconds=300`. Inside the App, `Model().predict.remote(text)` replaces the HTTP request; the [Functions guide](https://www.nodus-compute.ai/docs/guides/functions/) shows how another program looks up a deployed App.

## FAQ

### Is Beam open source?

Partly. Beam publishes [beta9](https://github.com/beam-cloud/beta9) on GitHub under the AGPL-3.0 license, described as serverless GPU inference, sandboxes and background jobs. The hosted platform is billed separately.

### Can you use AWS or GCP credits with these platforms?

On some. Beam’s [bring-your-own-cloud option](https://www.beam.cloud/pricing.md) bills the compute to your own AWS, GCP or Azure account. Cerebrium’s [pricing FAQ](https://www.cerebrium.ai/pricing) says AWS and GCP credits cannot be applied to its usage. Nodus can run work in a connected AWS, GCP or Azure account and spend your cloud credits first, a Beta feature in the [cloud accounts guide](https://www.nodus-compute.ai/docs/guides/pools/cloud-accounts/).

### How many GPUs can you run at once on Beam?

It depends on the plan. Beam’s [pricing page](https://www.beam.cloud/pricing.md) lists 5 concurrent GPUs on the $20-a-month Developer plan, which includes $20 of credits, and 50 on the $89-a-month Team plan. On Nodus, a Function’s `max_workers` goes up to 1,000, within your org’s [quotas](https://www.nodus-compute.ai/docs/guides/access/quotas/).
