Replicate Pricing 2026: Per-Second Cost vs Renting a GPU

Replicate charges $0.001525 per second for a single H100, which is $5.49/hr. That rate hasn't moved since Cloudflare agreed to acquire the company in November 2025, and it didn't move when the deal closed in early 2026 either. What changes the real cost isn't the acquisition, it's how many hours a day your GPU actually runs. This post covers every published Replicate rate, what the Cloudflare deal did and didn't touch, and the exact utilization point where a dedicated GPU rental gets cheaper than paying by the second.

If you're comparing Replicate against a longer list of platforms rather than just the raw numbers, our Replicate alternatives guide covers 10 options on cold starts, container flexibility, and migration effort. This post stays narrower: the pricing mechanism, the rate table, and the math.

Replicate's Actual Per-Second GPU Pricing in 2026 (Full Rate Table)

Replicate bills every GPU by the second, with no minimum increment published on its pricing page. The rate scales with GPU class and count, and the same per-second mechanism applies whether you're running a public model, a private one, or a token-billed LLM, though what you're metered on differs across those three cases.

Every Public GPU Rate: H100, A100, L40S, T4, and Multi-GPU Tiers

Source: Replicate's pricing page. CPU-only runs are billed separately: $0.000025/sec ($0.09/hr) for a small CPU instance, $0.000100/sec ($0.36/hr) for a standard one. Multi-GPU tiers above 8x require committed spend and aren't self-serve.

Every rate in that table holds regardless of whether the container is busy or waiting on a queue, as long as the instance is running. There's no discount for scale on the standard tiers: 8x H100 costs exactly 8 times the single-H100 rate, so pooling GPUs on Replicate doesn't buy you a lower per-GPU price the way a committed rental contract does elsewhere.

Public Models vs Private Models vs Token-Based Billing (Three Different Meters)

Replicate doesn't meter every model the same way, and this is where a lot of the confusion about "Replicate pricing" comes from.

• Public models are billed by wall-clock run time, the per-second rates above. Most of Replicate's catalog, which stood at over 50,000 production-ready models at the time of the Cloudflare announcement, falls into this bucket.
• Private models (your own custom Cog containers) are billed for the total time the instance is online, not just active inference. That includes setup time, idle time between requests, and processing time, all at the same per-second GPU rate. Fast-booting fine-tunes are the exception: those are billed only for active time.
• Token-based billing applies to specific hosted LLMs where Replicate passes through the model provider's own metering. Claude 3.7 Sonnet on Replicate, for example, runs $3.00 per million input tokens and $0.015 per thousand output tokens, unrelated to the per-second GPU rates above.

The practical implication: if you're running a private model with a scheduler that keeps the container warm between requests, you're paying for that warm-up window even when nothing is generating. That's a different cost profile than the "pay only when it runs" pitch usually associated with serverless inference, and it's worth checking which billing mode your specific deployment falls under before estimating a monthly number.

Replicate After the Cloudflare Acquisition: What Changed, What Didn't

Nothing in the per-second pricing mechanism changed. The acquisition is a corporate and infrastructure story, not a pricing one, and the two shouldn't get conflated when you're budgeting a Replicate deployment.

The Deal Terms and Timeline (Announced Nov 2025, Closed Early 2026)

Cloudflare announced its agreement to acquire Replicate on November 17, 2025, with the transaction expected to close within about two months. It closed in early 2026, and Replicate has continued operating as a distinct brand since, integrating with Cloudflare's Developer Platform and Workers ecosystem over the longer term rather than folding into it immediately.

Matthew Prince, Cloudflare's co-founder and CEO, framed the acquisition around discovery and deployment reach in Cloudflare's press release: "With Replicate, developers will be able to discover any model they want from one of the industry's largest catalogs, deploy it instantly on Cloudflare's global network, and build an entire full-stack application in one place." Ben Firshman, Replicate's co-founder and CEO, put it more bluntly: "Together, we're going to become the default for building AI apps."

What Cloudflare Actually Said Would Change (and What They Explicitly Said Wouldn't)

Replicate's own post-acquisition blog is specific on this point. Three things stay the same: "The API isn't changing," "The models you're using today will keep working," and Replicate "carr[ies] on as a distinct brand." The post adds that anything already built on Replicate "will keep running just like it does now." Firshman elaborated on the brand point directly: "Replicate's going to carry on as a distinct brand, and all that'll happen is that it's going to get way better."

Neither Replicate's blog post nor Cloudflare's press release mentions pricing changes, and none have followed since. If you were on Replicate's per-second billing before the deal, you're on the exact same rates now. The strategic upside Cloudflare is buying, broader distribution across its edge network and closer integration with Workers, is a roadmap story for later, not a line item on your current invoice.

The Break-Even Point: When Per-Second Billing Beats a Dedicated GPU Rental (and When It Doesn't)

Per-second billing wins decisively at low utilization and loses decisively at high utilization. The crossover is a specific number, not a vague "it depends," and it's lower than the pitch for serverless inference usually implies.

The Utilization Math: Replicate $5.49/hr Effective vs Spheron H100 On-Demand

Spheron's live H100 PCIe on-demand rate, fetched from its GPU offers catalog, is $2.01/hr. A dedicated rental at that rate runs whether it's busy or not, so its cost is flat: $2.01 x 24 x 30 = $1,447.20/month regardless of how many of those hours the GPU is actually doing work. Replicate's cost scales directly with active time. Line the two up across a monthly usage range and the crossover shows up as a specific point, not a fuzzy "it depends":

Under 263 active hours a month, roughly a third of the time, keep paying Replicate by the second. Past that point a dedicated instance is cheaper, and the gap compounds fast: at full-time utilization, Spheron on-demand runs 63% below Replicate's effective rate, a difference of about $2,506/month on H100 alone. That's not a hypothetical margin. Spheron's H100 PCIe on-demand rate of $2.01/hr and H100 SXM5 on-demand rate of roughly $4.41/hr, both fetched live, sit under Replicate's $5.49/hr regardless of which H100 variant you'd pick for the workload. H100 spot on Spheron, at roughly $2.94/hr for SXM5, pushes the gap wider still, with the standard caveat that spot capacity can be reclaimed.

The same math holds for A100. Replicate's A100 rate is $5.04/hr; Spheron's A100 80GB SXM4 on-demand rate is around $1.82/hr live, with spot down near $0.85/hr. Divide $1.82 by $5.04 and the A100 break-even lands at 36.1% utilization, almost identical to H100's crossover, because both GPUs sit at a similar ratio between Replicate's per-second rate and Spheron's hourly one.

Pricing fluctuates based on GPU availability. The prices above are based on 30 Jul 2026 and may have changed. Check current GPU pricing → for live rates.

Worked Example: FLUX.2/Wan Image and Video Generation at Volume

Image and video generation workloads make the utilization math concrete because each job has a fixed, measurable GPU time. FLUX.2-dev at full quality takes roughly 60 seconds of H100 time per image. At Replicate's rate, that's $0.0915/image, and the bill is linear: a team running 500 images a day, 15,000 a month, pays $1,372.50 on Replicate regardless of how those requests are spread across the day.

On a Spheron H100 PCIe rental running FLUX.2-dev in FP8, at roughly 14 images/min throughput, that same 15,000 images takes about 1,071 minutes of GPU time, just under 18 hours. At $2.01/hr with per-minute billing, that's about $35.90 for the month, roughly 97% less than Replicate's bill for the identical volume. The gap isn't close: Replicate's per-image rate is fixed regardless of volume, while Spheron's cost is driven by actual throughput on hardware you already have provisioned. For the deployment specifics behind that 14 images/min figure, FP8 quantization, and ComfyUI setup, see Deploy FLUX.2 on GPU Cloud. If your volume is on the lower end and unpredictable, Fal.ai covers the same per-second-billed territory as Replicate specifically for image and video models, with its own crossover math against bare-metal.

Video generation compounds the gap further because a single Wan clip can burn several minutes of GPU time rather than seconds. A team generating a few hundred clips a month at low volume is well inside Replicate's favorable zone. A team generating thousands of clips a day for a production feature crosses the break-even point fast, at which point the per-second meter is actively working against the budget rather than protecting it.

Migrating a Replicate Deployment to Your Own GPU Rental

Moving off Replicate isn't a rewrite. Cog, Replicate's container format, is a standard OCI Docker image under the hood, and that's the detail that makes migration a configuration change rather than an engineering project.

Cog Containers Are Just Docker Images: What the Move Actually Involves

A Cog container exposes an HTTP server on port 5000 with a single endpoint, POST /predictions, that accepts a JSON body and returns a JSON response. That's it. The image itself is a standard OCI artifact, so any host that can run docker run --gpus all with a port mapping can serve it, no Replicate-specific runtime required.

That single fact is the whole cost story in this post distilled into an engineering decision: since the container doesn't care where it runs, the choice between Replicate and a dedicated rental is purely about the utilization math above, not about rewriting anything. Our Replicate alternatives guide, linked above, has a full step-by-step migration playbook with the pull command, GPU selection, and the request-side code change, so it isn't repeated here.

Provision the GPU on Spheron, pick H100 or L40S depending on the model's VRAM needs, and you're running the same container that ran on Replicate's infrastructure, just billed hourly instead of per second. Once that's stable, some teams drop the Cog wrapper entirely and move to a purpose-built serving stack. For LLM workloads, that usually means vLLM behind an OpenAI-compatible endpoint. Our self-hosted OpenAI-compatible API guide covers that setup end to end, including batch size and KV cache tuning that a generic Cog container doesn't expose. For fine-tuning costs once you're off Replicate's hosted fine-tune API, see Fine-Tune Flux.2 and Wan 2.5 on GPU Cloud, and for the broader utilization-to-cost-per-token framework behind these numbers, see our AI inference cost economics guide.

Where Self-Hosting Doesn't Make Sense (Low-Volume, Bursty, Prototyping)

None of this is an argument to abandon Replicate outright. Below the roughly 37% utilization threshold, its per-second model is the right tool:

• Prototyping and demos. A model running a handful of requests a day has no business sitting on a dedicated instance racking up idle-hour charges.
• Genuinely bursty traffic with no predictable pattern. If you can't schedule the load, Replicate's scale-to-zero behavior is doing real work for you.
• Access to Replicate's model catalog itself. Beyond pricing, the value of not having to source, containerize, and validate a model yourself is real, especially for less common architectures.

The migration case gets stronger the moment usage stops being occasional and starts being scheduled: a production inference API running most of the day, a content pipeline generating images or video on a fixed cadence, or a fine-tuning workflow that needs raw checkpoint access Replicate's hosted fine-tune API doesn't expose. Our Replicate alternatives comparison linked above has a full decision matrix by use case, and Spheron vs Modal covers the bare-metal-vs-serverless tradeoff in more architectural depth if you're weighing more than one per-second-billed option.

Above roughly 37% utilization, Replicate's per-second meter has already crossed a dedicated H100's hourly rate. Check current GPU pricing →