If you deploy frontends, these are still the three dominant free hosts — global CDN, Git integration, PR preview URLs. What changed is that you can no longer line their free tiers up in a table and read off a winner, because they no longer measure the same thing.

The three free tiers measure three different things

This is the single most important fact about hosting in 2026, and most comparisons (including the earlier version of this one) still get it wrong:

Free-tier figures from Vercel's Hobby plan docs, Netlify's pricing page and Cloudflare Pages limits, checked 1 September 2026. Free tiers change without announcement — re-check before you plan around any of these.

Vercel used to publish a monthly build-minute allowance; it does not any more. Its Hobby plan page lists no build-minute line at all — the build limits are a 45-minute ceiling per deployment, 2 build vCPUs, and 100 deployments per day. Netlify's pricing page no longer contains the phrase "build minutes" either; builds are billed as production deploys plus compute out of the credit pool. So a "Vercel 6,000 min vs Netlify 300 min" row, which you will still find all over the web, compares two metrics that both stopped existing.

What 300 Netlify credits actually buy

Netlify's free plan is the one that changed most, and a credit number is impossible to reason about until you convert it. Netlify publishes the rates, so here is the arithmetic — spend it all on one thing and this is your ceiling:

The catch is that it is one pool, not five. Those rows are alternatives, not additions. A modest real month — 10 production deploys, 5 GB of bandwidth, 250,000 web requests — costs 150 + 100 + 50 = exactly 300 credits. That is the entire free plan, for a site most people would describe as quiet. The same workload does not come close to a limit on either of the other two.

Two consequences worth stating plainly. First, 15 GB is the absolute bandwidth ceiling, and only if you never deploy — a long way from the 100 GB the old pricing model gave. Second, free forms are no longer free of consequence: form submissions draw on the same 300 credits, so the feature Netlify was most often recommended for now competes with your bandwidth. Add-on credits are sold on the paid plans ($5 / 500 credits on Personal), but the Free plan is a hard 300-credit limit.

Vercel Hobby: metered on CPU, and explicitly non-commercial

Vercel built Next.js, and it shows — SSR, React Server Components, Edge Functions and App Router all work with zero configuration. The free allowance:

4 Active-CPU-hours is the number to watch, and it is the one nobody quotes. Static asset serving does not touch it, but every SSR render, API route and middleware invocation does. A server-rendered app with real traffic will exhaust CPU hours long before it approaches 100 GB of transfer — which is precisely why Vercel changed what it meters.

The other constraint is legal, not technical: Vercel's own documentation states that "the Hobby plan restricts users to non-commercial, personal use only." That is an explicit clause, and it rules the free tier out for anything with revenue attached, however small. Exceed a Hobby limit and the feature pauses until the 30-day window rolls over rather than generating a bill.

Netlify: one credit pool, and a very low deploy ceiling

Netlify pioneered modern static hosting, and the free plan still includes the things it is loved for — unlimited deploy previews, branch and PR previews, custom domains with SSL, functions, Blob storage, a Postgres database (Basic tier), firewall traffic rules and the global CDN. One concurrent build, one Preview Server, 1-day analytics retention.

# Deploy any static site
npm install -g netlify-cli
netlify login
netlify deploy --dir=./dist --prod

Netlify auto-detects React, Vue, Svelte, Gatsby, Hugo, Jekyll and Astro. Functions dropped in netlify/functions/ are served automatically at /.netlify/functions/<name>, and its signature feature is still a server-free form backend — add data-netlify="true" to any HTML form and Netlify captures submissions.

Plan around the 20-deploy ceiling. At 15 credits per production deploy, a team pushing to main a few times a day will burn the entire month's credits on deploys alone before serving a single visitor. This is the single biggest behavioural change in the new model and the reason a CI-heavy project should not start here. Unlike Vercel, Netlify publishes no non-commercial restriction on its free plan.

Cloudflare Pages: the only uncapped bandwidth left

Cloudflare is the outlier, and in 2026 it is the outlier in the right direction: it does not bill for bandwidth or egress at all, on any plan. What it meters instead is requests to Functions, which are billed as Workers.

The real constraint is 10 ms of CPU per invocation. That is generous for routing, auth checks, redirects and API proxying, and far too little for anything compute-heavy — Cloudflare Pages Functions are not the place to render a large React tree server-side. Note also two ceilings the other platforms do not have: a hard 20,000-file limit per site, which a large documentation site or an image-heavy static export can genuinely hit, and a 25 MiB cap per individual asset (serve larger files from R2).

One correction to the version of this article you may have read before: custom domains are not unlimited on any of the three. Cloudflare allows 100 per project on Free, Vercel allows 50 per project on Hobby.

Performance

All three serve static assets fast via global CDN. The differences show up in TTFB for dynamic rendering and in function cold starts:

All three serve static assets from a global CDN, and for static files the difference is not something a table can honestly capture: time-to-first-byte depends on where your visitor is standing, and build time depends on your project, not the platform. We have not measured these across the three platforms, so we are not going to publish numbers for them.

The difference that is structural rather than incidental is how a function starts. Vercel and Netlify run your handler in a Node.js runtime that has to be spun up when no warm instance is available — the classic cold start. Cloudflare Workers run in V8 isolates, the same mechanism that separates browser tabs, which start far more cheaply because there is no container or process to boot. That is an architectural property, not a tuning difference: if your workload is bursty and latency-sensitive, it is the single biggest reason to look at Cloudflare, and no amount of configuration closes the gap on the other two.

Cloudflare's V8 isolate model eliminates cold starts entirely — a meaningful edge for latency-sensitive APIs. On framework support, Vercel is native for Next.js (React Server Components, App Router, streaming), while Cloudflare has excellent official adapters for Remix and SvelteKit, and Netlify shines on Gatsby, Hugo, and Jekyll builds. For most other frameworks, all three are roughly equivalent.

Add AI with Serverless Functions

All three support serverless functions, making them good hosts for AI-powered frontends via OpenClaw — keep API keys server-side while serving the UI globally:

// app/api/analyze/route.ts (Vercel, Next.js App Router)
import { NextRequest, NextResponse } from 'next/server';

export async function POST(req: NextRequest) {
  const { text } = await req.json();
  const response = await fetch('https://api.openclaw.ai/v1/run', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.OPENCLAW_API_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ task: `Summarize key points: ${text}` }),
  });
  return NextResponse.json(await response.json());
}

The same pattern works on Netlify and Cloudflare Pages Functions — adapt to each runtime. The frontend calls /api/analyze and gets results without exposing keys to the browser. On Cloudflare, keep the handler thin: 10 ms of CPU per invocation is the budget, and awaiting an upstream API does not count against it.

Paid plans (when you outgrow free)

Two things stand out. Netlify's Pro plan is $20/month with unlimited members, which is materially cheaper than Vercel's per-seat pricing for a team of any size. And Cloudflare's $5/month Workers Paid plan remains the best value at scale by a wide margin — 10 million requests and no egress charges, powering both Workers and Pages Functions.

Pick by your bottleneck, not by brand

Since the three platforms meter different things, the useful question is not "which is best" but "which meter will my project trip first":

• Serving a lot of bytes (media, downloads, a popular static site) → Cloudflare Pages. Uncapped bandwidth is the one genuinely unlimited resource left in free hosting.
• Deploying often (CI on every push, preview-driven workflow) → Cloudflare (500 builds/month) or Vercel (100/day). Netlify's ~20 production deploys a month is the tightest ceiling of the three.
• Server-rendering React → Vercel, with 4 Active-CPU-hours as the real limit — but only for a personal project, because Hobby is non-commercial.
• Anything commercial → Cloudflare Pages or Netlify. Neither publishes a non-commercial restriction; Vercel explicitly does.
• Heavy compute per request → none of the three on free. Cloudflare caps CPU at 10 ms, Vercel at 4 hours a month. Use Render or Railway for a long-running process instead.
• A form backend → still Netlify, but budget for it now that submissions draw on the same 300 credits.

None of the three hosts a persistent always-on server process or a database of any size — for that, see our roundup of free hosting platforms, or free hosting for AI agents if you need an always-on worker. Free-tier terms moved twice on this page in a single year, so confirm the current numbers on each provider's own pricing page before you architect around a limit.