Web Hosting Pricing: Examples & Companies

What is it

Web hosting pricing is pricing for platforms that host web applications, typically billed across multiple dimensions — bandwidth, requests, compute, and storage.

Hosting is the most-dimensional pricing category in the corpus. A flat monthly fee cannot fairly price a platform whose cost is driven by several independent resources at once, so hosting vendors break the bill apart: egress bandwidth, request volume, CPU or GPU time, and persistent storage each get their own meter. Vercel takes this furthest — its frontend cloud meters eight separate dimensions in parallel on a single bill: seats, Fast Data Transfer, edge requests, function invocations, active CPU, memory GB-hours, tokens, and builds.

The category spans two related worlds. Application platforms and AI coding environments host apps and lead with a per-seat fee plus usage. GPU and inference clouds — RunPod, Vast.ai, Baseten, Anyscale, DeepInfra, Fireworks AI, Novita AI, Hyperbolic, BentoML, Hugging Face — host models, vector data, and raw compute rented by the hour or second. Both share the same structural problem: the bill has many moving parts, and predicting a five-to-eight-input total is genuinely hard.

How it works

Hosting platforms meter several resource dimensions independently and sum them into one invoice. The exact dimensions vary by what the platform actually hosts, but they fall into four families:

Three pricing shapes dominate. Seat-plus-metering anchors a fixed per-seat fee, then bills usage on top — this is Vercel’s hybrid model: $20/seat/month on Pro, which also carries a $20 flexible spending credit drawn down across dimensions before overages start; Replit AI runs the same shape, bundling a literal dollar wallet ($25 on Core, $100 on Pro) inside the seat. Pure per-unit compute charges only for resources consumed with no seat fee — the model used by every raw GPU cloud here, from Vast.ai’s marketplace rates to RunPod’s per-hour Pods and per-second Serverless, Hyperbolic’s prepaid GPU-hour and per-million-token balance, and BentoML’s per-second dedicated instances. Usage-priced storage applies where the persistent asset is the cost driver — Weaviate bills on vector dimensions stored (objects × embedding size) rather than pods or nodes.

Unit math (Vercel Pro): Monthly bill = (seats × $20) + max(0, bandwidth − 1 TB) × rate + max(0, edge_requests − 10M) × rate + … − $20 included credit, applied across dimensions in priority order.

Unit math (GPU cloud): Monthly bill = Σ (GPU_hours × $/hr) + (storage_GB × $/GB/hr × hours) + (bandwidth_TB × $/TB). Reserved or committed terms discount the $/hr — Vast.ai up to 50% off, Anyscale and DeepInfra via annual commits.

Unit math (vector DB — Weaviate): Monthly bill ≈ (objects × embedding_dimensions ÷ 1,000,000) × $0.003875 + storage_GiB × $/GiB, plus per-token Embeddings and per-request Query Agent add-ons.

The recurring trade-off is reliability versus price on the same hardware. RunPod prices this explicitly: its Community Cloud runs 20–40% below its SLA-backed Secure Cloud for the same GPU model. Vast.ai prices it through interruptibility — its spot tier is 50%+ cheaper because an outbid job is paused rather than guaranteed. And on the metering unit itself, BentoML resolves the reliability-versus-cost tension a third way: per-second billing plus scale-to-zero means an idle deployment costs nothing, so you keep dedicated-instance performance without paying for warm-but-idle GPUs.

Companies using this

Thirteen companies in the corpus tag hosting as a primary use case — one frontend application platform (Vercel), one AI coding workspace (Replit AI), one AI-native vector database (Weaviate), and ten GPU, inference, or model-hosting clouds. The table below lists each with its pricing model, billing units, and free-tier status. Use the Vercel pricing calculator and the guides linked at the foot of the page to model a specific workload.

Patterns observed

• Multi-dimensional metering is the norm, not the exception. Every company on this page bills at least two dimensions in parallel. Vercel leads with eight, Novita AI meters five (tokens, GPU-hours, CPU-hours, GB-hours, and per-second sandboxes), DeepInfra spans tokens, GPU-hours, and requests, and Weaviate bills vector dimensions plus per-token Embeddings and per-request Query Agent. Single-unit hosting effectively does not exist in the corpus.

• GPU-hours are the dominant compute unit — but the billing granularity varies. Ten of the thirteen meter GPU time directly. RunPod (RTX 4090 at $0.69/hr, H100 PCIe at $2.89/hr), Vast.ai (from $0.194/hr), Baseten (H100 at $6.50/hr), Anyscale (H100 at $9.2880/hr fully-managed), DeepInfra, Fireworks AI (H100 at $7.00/hr), Hyperbolic (H100 from $1.50/hr), and Hugging Face all quote per-hour GPU rates as the headline number. But BentoML and Novita AI move to per-second granularity — the same cost center, billed at finer resolution to serve bursty inference.

• A commitment tier sits behind almost every usage meter. Most companies here carry a commitment taxonomy tag alongside pure-usage: Anyscale, Baseten, DeepInfra, Fireworks AI, RunPod, Vast.ai, Hyperbolic, BentoML, and Weaviate all let steady workloads pre-pay or commit for a discount. Pure usage is the on-ramp; commits are how the platform earns predictable revenue. Weaviate makes the ladder explicit — free OSS self-host → monthly-card Flex → annual-prepaid Plus/Premium → quoted Enterprise, all on one engine.

• Open-core and pass-through pricing widen the funnel. Several hosts monetize compute around a free core. BentoML keeps the framework free and self-hostable, gating priority A100/H100/H200 behind a flat $1,000/mo Pro fee; Weaviate ships a free BSD-3 engine plus a no-credit-card sandbox; and Hugging Face passes routed Inference Providers through at zero markup, turning serverless inference into a funnel rather than a margin center. Free entry points cluster on the application and inference side — Vercel (Hobby), Replit AI (Starter), Baseten, Anyscale, Fireworks AI, Novita AI, Hyperbolic ($5 credit), and Weaviate all offer them — while the raw GPU marketplaces Vast.ai, RunPod, and DeepInfra do not: when you are renting physical hardware by the second, a free tier is harder to absorb.

Counterexamples & variants

The clearest variant is the marketplace model, where the platform does not set prices at all. Vast.ai is the standout: every GPU $/hr is set by the host machine’s owner and floats with supply and demand, and its serverless tier carries no surcharge — it simply bills at the underlying GPU rate plus a $5 minimum. Hyperbolic is a softer version of the same idea: it aggregates third-party GPU supply (a DePIN model) and refreshes per-hour rates weekly off the best available supplier prices, so its H100-from-$1.50/hr rate is a moving spot price rather than a fixed list. This breaks the usual assumption that “hosting pricing” means a vendor-published rate card — on these platforms the rate card is a live auction.

A second variant swaps the billing unit away from compute entirely. Weaviate bills on vector dimensions stored (objects × embedding size), not GPU-hours or pods, and its Plus and Premium tiers share the same $0.003875/1M dimension rate — the price step between them buys uptime SLA (99.5% → 99.9% → 99.95%) and support, not a better unit rate. Reliability and usage rate are deliberately decoupled, which is the opposite of the GPU clouds where the SLA is baked into the hourly rate (RunPod Secure vs Community).

The seat-plus-metering shape is a near-singleton on the app side. Vercel and Replit AI are the only two companies here that charge a per-seat fee, because they sell to teams shipping apps. Replit AI also shows how volatile AI cost stresses the model: it abandoned a flat $0.25-per-checkpoint fee for effort-based Agent billing — each request priced on the time and compute it actually consumed — because a fixed per-task price under-charges complex work and over-charges trivial edits. The raw GPU clouds deliberately avoid seats altogether: for compute rental, a seat fee would be friction with no corresponding cost driver, so they price purely on consumption.

What this means for buyers vs vendors

For buyers

Forecasting is the hard part. A hosting bill with five-to-eight inputs cannot be estimated from a single headline rate, so model each dimension against your actual workload shape — egress, request volume, and compute hours rarely scale together. Watch how included quotas and credits interact: Vercel’s $20 Pro credit is consumed in priority order across dimensions, so a bandwidth spike can quietly exhaust the credit you were relying on to cover function calls, and Replit AI’s dollar-denominated wallet means “how many tasks is $25” is genuinely opaque until you run real work through it.

For GPU work, match the tier to your tolerance for interruption and your job’s duration. Fault-tolerant batch jobs belong on Vast.ai spot (from ~$0.194/hr) or RunPod Community, while production inference justifies SLA-backed Secure capacity or a reserved commit. If your inference is short and bursty, per-second platforms like BentoML (with scale-to-zero) or Novita AI stop you paying for warm-but-idle GPUs; if it is steady and predictable, an annual commit on Anyscale, DeepInfra, or Fireworks AI discounts the hourly rate. And if the persistent asset is data rather than compute — a vector index — price it on Weaviate’s per-dimension math up front, since large indexes get expensive far above the low plan floors. See the guide to choosing the right usage metric before locking in, and the prepaid credits guide for how wallet-style plans draw down.

For vendors

The central tension is accuracy versus explainability. Metering eight dimensions prices consumption fairly but produces a bill customers struggle to predict — Vercel manages this with a single flexible credit that absorbs overages so most users see one number, not eight, and Replit AI buries variable Agent cost inside a seat-price wallet so light users never see the meter at all. Choosing a metric the buyer can compute themselves is the trust move: Weaviate bills on vector dimensions precisely because a buyer can estimate embedding size × objects × queries before signing up.

If you sell raw compute, a published per-unit rate plus a commitment tier (the pattern across Anyscale, DeepInfra, Fireworks AI, and Hyperbolic) lets price-sensitive users self-serve while steady workloads convert to predictable, discounted revenue. Decide deliberately whether reliability is a separate SKU (RunPod’s two clouds), a market mechanic (Vast.ai’s spot bidding), or an SLA ladder decoupled from unit rate (Weaviate’s Plus/Premium). And consider open-core as the top of the funnel: BentoML and Weaviate give the framework and engine away free, monetizing only the managed runtime, while Hugging Face passes routed inference through at zero markup to consolidate developer attention before charging for endpoints and seats. The introduction to usage-based pricing and the usage invoicing and billing cycles guide cover the structural choices.

Explore this theme in the knowledge graph →