Modal vs Replicate vs Baseten for Indie Hackers in 2026

Every comparison of these three opens with a table of hourly GPU rates. Modal's H100 is cheapest, Replicate's costs more, Baseten's costs most. Pick the cheap one, done.

Then you run an actual workload through all three and the ranking flips. Not by a little. By more than an order of magnitude, in the opposite direction from what the hourly rates predict.

The reason is that almost nobody scraping by on a side project keeps a GPU busy. You have bursts of traffic and long gaps, and what you pay for during the gaps is the entire ballgame. So this post prices one concrete workload, 200 image generations a day at roughly 8 seconds of GPU time each, and shows what each platform actually bills.

Every price below came from the vendor's own pricing page or docs on September 12, 2026.

Quick Verdict

What Do These Three Actually Charge Per Hour?

The headline rates, verified today. Modal publishes per second and Baseten per minute, so the hourly columns below are arithmetic on their published figures rather than numbers they print themselves.

Modal's H100 SXM5 is $0.001097 per second. Replicate prints "$5.49/hr" next to $0.001525 per second. Baseten quotes an H100 80GB at $0.10833 per minute and never prints a headline hourly rate, so the $6.50 is a conversion you do yourself.

On Modal, CPU and memory bill separately from the GPU, at $0.0000131 per core-second and $0.00000222 per GiB-second. The others fold that into the hardware rate.

Why Does the Billing Unit Matter More Than the Rate?

Because the unit decides what happens in the gaps, and for an indie project the gaps are most of the day.

Modal bills per second with no minimum. Their billing docs say it plainly: "Reservations are not required, and there are no minimum usage-time increments." The pricing page goes further, claiming "You never pay for idle resources."

That claim doesn't survive their own cold start documentation, which says "you will be billed for any resources used while the container is idle (e.g., GPU reservation or residual memory occupancy)." Both statements are Modal's. The docs are the accurate one. What you control is scaledown_window, the idle timeout before a container dies, configurable from 2 seconds to 20 minutes.

Baseten bills per replica minute and rounds partial minutes up. From their billing docs: "Baseten meters usage by the minute while a workload is running on a node." Worth being precise here, because secondary sources get it wrong. The meter runs per running replica, not per request. A replica serving 100 requests over 15 minutes bills about 15 minutes, not 100 rounded-up minutes.

The number that actually costs you money is scale_down_delay, and its default is 900 seconds. Fifteen minutes where the replica is still running after your last request. The docs say you "pay for usage up to the moment the replica terminates, and partial minutes round up", and that metering runs "while a workload is running on a node", so that window bills. Cold starts and model loading bill too: "During startup, billing is per minute even though the replica isn't yet serving responses."

Replicate has two completely different cost shapes on one platform. For public catalog models, "you only pay for the time it's active processing your requests. Setup and idle time for the model is free." For private models and deployments, you "pay for all the time instances of the model are online," setup and idle included. Same company, opposite economics. Get this backwards and your bill moves by 10x.

Catalog models are also priced per output, not per second:

An 8-second generation and a 3-second generation cost the same. Duration stops being a variable.

What Does 200 Images a Day Actually Cost?

200 generations at 8 seconds is 1,600 seconds of GPU time a day, about 13.3 hours a month. Here's what each platform bills for that same work, assuming traffic arrives in roughly 24 bursts through the day.

Look at the Modal rows. Same GPU, same 1,600 seconds of real work, and the bill moves from $53 to $1,000 on one config value. The hourly rate never changes. Your scaledown_window does.

Baseten's H100 has the highest headline rate of the three, but that's not why it lands at the top of this table. It's the 900-second default idle delay multiplied by every burst, with each burst's partial minute rounded up. Lower scale_down_delay and that number drops hard. Leave the default on bursty traffic and you pay for roughly six hours of idle H100 a day.

And Replicate, whose H100 costs 39% more per hour than Modal's, comes out cheapest by a mile on a catalog model, because the question of how long a GPU sat warm never arises.

So the ranking by hourly rate is Modal, Replicate, Baseten. The ranking by what you'd actually pay is Replicate, Modal, Baseten, and the gap between first and last is more than 70x.

When Is Each One the Right Call?

Pick Replicate catalog models when a standard model does the job. Flux, SDXL, Whisper, the usual suspects. Bursty traffic is free of idle cost, failed runs aren't charged ("If a run fails, we don't charge you", except on private deployments), and you can ship in an afternoon. This is where most indie projects should start.

Pick Modal when you need your own code around the model, custom preprocessing, a pipeline, or a model nobody hosts. Per-second billing with no minimum is the most honest unit of the three, and the $30 monthly free credit covers a lot of experimentation. Set scaledown_window deliberately, because the default will quietly decide your bill.

Pick Baseten when traffic is steady enough to keep a replica properly busy. Per-minute metering stops being a penalty once your replica isn't idling, their cold start engineering is real, and dev deployments aren't billed at all, which makes iteration cheap. For a solo project with spiky traffic and default settings, it's the most expensive way to run this workload.

When should you not use any of them?

If you're under a few hundred requests a day on a standard model, a hosted API is simpler and cheaper than all three. We worked through that break-even in when to use LiteLLM self-hosted vs a managed AI gateway, and the same logic applies to image work.

If you're running models locally already, the local AI coding tools roundup covers where a machine you already own beats renting one.

A Note on Benchmarks You'll Find Searching This

There's a site ranking high for serverless GPU cold starts that reports Modal at 1.8 seconds, RunPod 4.2, Replicate 6.5, with a stated methodology of 500 cold invocations per provider. Tempting to cite. I'm not going to, because its Modal A100 40GB price ($2.85/hr) and Replicate A100 80GB price ($4.14/hr) both contradict the vendors' own pages, which say $2.10 and $5.04. A benchmark that gets published list prices 18% wrong isn't a benchmark I'd trust on latency.

The vendors' own cold start claims, for what they're worth: Modal's docs say "Containers boot in about one second." Baseten's blog claims "cold start times of 9 seconds, from zero to ready for inference" for Stable Diffusion XL on an A100. Replicate publishes no number, saying only that setup "can take a few seconds." Two vendor claims and one absence, which is the honest state of the public record.

My Recommendation

Start on Replicate catalog models. At 200 images a day the per-output model is cheapest, the idle question disappears, and you'll know within a week whether the feature matters to anyone.

Move to Modal when you outgrow the catalog, either because you need custom code or because your volume is high enough that per-second billing beats per-image. Set the scaledown window yourself on day one.

Consider Baseten when your traffic flattens out into something steady. Its economics reward a busy replica and punish an idle one, which is the opposite of what a side project's traffic looks like early on.

flowchart TD
    A{Standard model from a catalog?} -- yes --> B{Traffic bursty?}
    A -- no --> C{Need custom code around it?}
    B -- yes --> D[Replicate catalog, per output]
    B -- no --> E{Replica busy most of the hour?}
    C -- yes --> F[Modal, short scaledown window]
    C -- no --> D
    E -- yes --> G[Baseten, lower scale_down_delay]
    E -- no --> F

We covered the hosted end of this market in the Hugging Face inference alternatives post, and the routing layer above it in the OpenRouter alternatives roundup.

The number to check before you commit to any of these isn't the hourly rate on the pricing page. It's the idle timeout in your deployment config, because that's the one you're actually going to pay.

Found a better option? Let me know on Twitter @devtoolpicks.