Vercel vs Netlify vs Cloudflare Pages API
Three Deployment Platforms. One Decision.
Every web application deployed in 2026 eventually lands on one of three platforms. Vercel is the Next.js home court with the fastest CI/CD feedback loop. Netlify built JAMstack and remains the most framework-agnostic option with a new credit-based pricing model. Cloudflare Pages offers unlimited bandwidth, 50ms TTFB, and the deepest edge computing integration available.
The choice between them is increasingly a function of three things: your framework choice, your expected traffic scale, and whether you need edge computing beyond static hosting.
TL;DR
Vercel is the default for Next.js teams — the native integration is genuinely unmatched and the 70ms TTFB speaks for itself. Cloudflare Pages wins on cost at scale with unlimited bandwidth and the lowest edge latency (50ms TTFB) — the right choice for high-traffic sites where bandwidth costs would otherwise compound. Netlify's credit-based model (introduced 2025) simplifies billing but makes cost modeling harder for compute-heavy applications.
Key Takeaways
- Cloudflare Pages delivers 50ms average TTFB — the fastest of the three platforms on edge content delivery.
- Cloudflare's free tier includes unlimited bandwidth — unique in the market. Vercel free is 100GB; Netlify free uses credit system.
- Vercel Pro costs $20/user/month with 1TB bandwidth — the right choice for professional Next.js teams where the native integration delivers real developer productivity.
- Netlify switched to credit-based pricing in 2025 — all new accounts use credits that apply to compute, bandwidth, builds, and forms.
- Vercel Hobby is not for commercial use — the free tier explicitly prohibits commercial applications. Pro ($20/user) is required.
- Cloudflare Workers (serverless compute) integrates directly with Pages — giving Cloudflare Pages the most complete edge computing story.
- All three have deployment APIs — allowing programmatic deploys, preview environments, and CI/CD integration outside of their native Git hooks.
Platform Overview
| Platform | TTFB | Free Bandwidth | Paid Starting | Best For |
|---|---|---|---|---|
| Cloudflare Pages | 50ms | Unlimited | $5/month (Workers) | High-traffic, edge, cost-efficiency |
| Vercel | 70ms | 100GB | $20/user/month | Next.js, professional teams |
| Netlify | 90ms | Credits-based | ~$20/user/month | Framework-agnostic, JAMstack |
Vercel
Best for: Next.js applications, professional developer teams, best DX for React ecosystem
Vercel is built by the Next.js team — so the integration between the framework and the platform is architecture-deep, not just API calls. Server Components, ISR (Incremental Static Regeneration), Image Optimization, Edge Runtime, and Fluid Compute all work because Vercel and Next.js evolve together.
Pricing (2026)
| Plan | Cost | Bandwidth | Edge Requests | Function Invocations |
|---|---|---|---|---|
| Hobby | Free | 100GB | 1M | 1M |
| Pro | $20/user/month | 1TB | 10M | Unlimited |
| Enterprise | Custom | Custom | Custom | Custom |
Important: The Hobby plan is for personal, non-commercial use only. Any commercial deployment requires Pro at $20/user/month minimum.
Overages on Pro:
- Bandwidth: $0.15/GB after 1TB
- Edge Requests: $2/1M after 10M
- Function CPU: $0.05/GB-hour after included
Deployment API
Vercel provides a comprehensive REST API for programmatic deployments:
// Create a deployment via API
const response = await fetch("https://api.vercel.com/v13/deployments", {
method: "POST",
headers: {
"Authorization": `Bearer ${VERCEL_TOKEN}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
name: "my-app",
project: "project-id",
files: [
{ file: "index.html", data: btoa("<h1>Hello</h1>") },
],
projectSettings: {
framework: "nextjs",
},
}),
});
const deployment = await response.json();
console.log(`Deployed to: ${deployment.url}`);
Preview deployments: Every Git branch automatically gets a preview URL — critical for team review workflows:
# Check deployment status via API
curl -H "Authorization: Bearer $VERCEL_TOKEN" \
"https://api.vercel.com/v13/deployments?projectId=proj_xxx&limit=5"
Edge Functions and Fluid Compute
Vercel's Fluid Compute (2025) intelligently routes between serverless and edge based on your code:
// app/api/route.ts — automatically optimized
export const runtime = "edge"; // Run at edge globally
export async function GET(request: Request) {
const country = request.headers.get("x-vercel-ip-country");
return Response.json({ country, timestamp: Date.now() });
}
Next.js Integration Depth
No other platform matches Vercel for Next.js-specific features:
- App Router with Server Components — zero-config support
- ISR with
revalidatePath()andrevalidateTag() - Image Optimization with
next/image— on-demand resizing, WebP conversion - Analytics and Speed Insights built in
- Preview Mode for draft content
When to choose Vercel
Next.js applications, professional teams where developer experience translates to productivity, applications using Server Components or ISR, or any commercial React/Next.js deployment where the native integration pays for itself.
Cloudflare Pages
Best for: High-traffic sites, edge computing, cost efficiency, unlimited bandwidth
Cloudflare Pages runs on Cloudflare's global edge network — 300+ PoPs worldwide. The result: 50ms average TTFB, unlimited free bandwidth, and native integration with Workers (Cloudflare's V8-based serverless compute), KV (key-value store), D1 (SQLite database), and R2 (object storage).
Pricing
| Feature | Free | Workers Paid ($5/month) |
|---|---|---|
| Sites | Unlimited | Unlimited |
| Bandwidth | Unlimited | Unlimited |
| Builds | 500/month | 5,000/month |
| Static Requests | Unlimited | Unlimited |
| Workers invocations | 100K/day | 10M/month |
| Workers KV reads | 100K/day | 10M/month |
The killer feature: unlimited bandwidth on the free tier. For high-traffic marketing sites, documentation, or content that occasionally goes viral, Cloudflare Pages eliminates the bandwidth cost anxiety of other platforms.
Workers Integration
Cloudflare Pages + Workers = a complete edge application platform:
// pages/functions/api/[[route]].ts
// Runs at the edge, globally, with zero cold starts
import { createRequestHandler } from "@cloudflare/workers-router";
export const onRequest: PagesFunction = async (context) => {
const { env, request } = context;
// D1 — edge SQLite database
const db = env.DB;
const users = await db.prepare("SELECT * FROM users LIMIT 10").all();
// KV — edge key-value store
const cached = await env.KV.get("dashboard-data");
// R2 — edge object storage
const bucket = env.R2_BUCKET;
return Response.json({ users: users.results });
};
Deployment API
# Deploy via Cloudflare Pages API
curl -X POST "https://api.cloudflare.com/client/v4/accounts/{account_id}/pages/projects/{project_name}/deployments" \
-H "Authorization: Bearer $CF_API_TOKEN" \
-H "Content-Type: multipart/form-data" \
-F "manifest={\"_worker.js\":\"dist/_worker.js\"}" \
-F "_worker.js=@dist/_worker.js"
Via Wrangler CLI (recommended):
# Deploy with Wrangler
npx wrangler pages deploy ./dist --project-name my-site
# Create preview deployment
npx wrangler pages deploy ./dist --project-name my-site --branch feature/new-design
Cloudflare Pages vs Workers
For server-rendered applications, Cloudflare offers two deployment models:
- Pages + Functions: Static assets with serverless functions for dynamic routes
- Workers (standalone): Pure serverless compute without static hosting
For most web applications, Pages + Functions is the recommended approach.
Performance Profile
- TTFB: ~50ms globally (best of three platforms)
- Static assets: Served from edge PoP closest to user — near-instant
- Workers: No cold starts (V8 isolates, not containers)
- Geographic distribution: 300+ data centers
When to choose Cloudflare Pages
High-traffic sites where bandwidth costs compound, cost-conscious teams that need global distribution, applications leveraging Cloudflare Workers/D1/KV/R2, applications where 50ms TTFB matters, or any project where unlimited bandwidth is a real concern.
Netlify
Best for: Framework-agnostic deployments, teams wanting breadth of built-in features
Netlify is the original JAMstack platform and remains the most framework-agnostic of the three. It deploys Next.js, Astro, Gatsby, Hugo, Jekyll, SvelteKit, and dozens of other frameworks with equivalent quality.
Credit-Based Pricing (2025)
Netlify switched all new accounts to credit-based pricing in September 2025. Credits apply across compute, bandwidth, builds, and forms:
| Plan | Monthly Credits | Cost | Per Credit |
|---|---|---|---|
| Free | 300 | $0 | — |
| Starter | 1,500 | ~$20/month | — |
| Pro | 5,000 | ~$65/month | — |
Credit consumption rates:
- Build: 15 credits per production deploy
- Compute: 5 credits per GB-hour
- Bandwidth: 10 credits per GB
- Forms: 1 credit per submission
Cost modeling example: An app with 100 deploys/month + 10GB bandwidth/month + 5GB-hours compute:
- Builds: 100 × 15 = 1,500 credits
- Bandwidth: 10 × 10 = 100 credits
- Compute: 5 × 5 = 25 credits
- Total: 1,625 credits/month → Starter plan
The credit system simplifies billing by unifying all resources under one currency, but makes accurate cost projection harder than Vercel's explicit per-resource pricing.
Deployment API
// Netlify Deploy API
const FormData = require("form-data");
const fetch = require("node-fetch");
async function deploy(siteId, buildDir) {
const form = new FormData();
form.append("files", fs.createReadStream(`${buildDir}/index.html`), "index.html");
const response = await fetch(
`https://api.netlify.com/api/v1/sites/${siteId}/deploys`,
{
method: "POST",
headers: {
Authorization: `Bearer ${NETLIFY_TOKEN}`,
...form.getHeaders(),
},
body: form,
}
);
return response.json();
}
Built-In Features
Netlify includes several capabilities that require separate services on other platforms:
Forms: Submit HTML forms without a backend — Netlify captures submissions automatically. Costs 1 credit per submission.
Identity: Built-in user authentication with JWT tokens and role management.
Split Testing: A/B test different branches directly in the UI without code changes.
Large Media: Git-based large file management (replaces Git LFS).
Framework Support
Netlify's breadth is genuinely better than Vercel for non-Next.js frameworks:
- Astro: Full SSR support, image optimization
- Gatsby: Deep integration with Gatsby Plugins
- Hugo: Fastest build times for static sites
- SvelteKit: First-class support
- Ruby on Rails: Via Netlify's build plugins
When to choose Netlify
Non-Next.js applications, teams using Gatsby or Astro, applications needing built-in forms or A/B testing, or teams that want a mature JAMstack platform with the broadest framework support.
Head-to-Head Comparison
| Feature | Vercel | Cloudflare Pages | Netlify |
|---|---|---|---|
| TTFB | 70ms | 50ms | 90ms |
| Free bandwidth | 100GB | Unlimited | Credits |
| Pricing model | Per-user + overages | Usage-based | Credits |
| Next.js integration | Native | Good | Good |
| Edge computing | Edge Functions | Workers + full stack | Edge Functions |
| Cold starts | Near-zero | None | Near-zero |
| Build time | Fast | Fast | Fastest for static |
| Free tier commercial | No | Yes | No |
| Deployment API | Comprehensive | Comprehensive | Comprehensive |
| Form handling | No | No | Yes |
| Database at edge | No | D1 + KV | No |
Deployment API Comparison
All three platforms expose programmatic deployment APIs for CI/CD, preview environments, and automation:
| API Feature | Vercel | Cloudflare | Netlify |
|---|---|---|---|
| Create deployment | Yes | Yes | Yes |
| List deployments | Yes | Yes | Yes |
| Get deployment status | Yes | Yes | Yes |
| Rollback deployment | Yes | Yes | Yes |
| Preview URLs | Yes | Yes | Yes |
| Environment variables API | Yes | Yes | Yes |
| Webhooks (deploy events) | Yes | Yes | Yes |
| CLI tooling | Vercel CLI | Wrangler | Netlify CLI |
Cost Comparison at Scale
For a site with 1TB/month bandwidth, 10M function invocations, 5GB-hours compute:
| Platform | Monthly Cost |
|---|---|
| Cloudflare Pages (Workers Paid) | $5 base + usage |
| Vercel Pro (1 user) | $20 base |
| Netlify Pro | ~$65 (credit estimate) |
Cloudflare's unlimited bandwidth model provides the clearest cost advantage at scale. At 10TB/month bandwidth:
- Cloudflare: Still $5/month base
- Vercel: $20 + (9TB × $0.15) = $1,370/month
- Netlify: Credits-based, can be significant
Decision Framework
Choose Vercel if:
- Building with Next.js (especially App Router, Server Components, ISR)
- Commercial application requiring Pro tier features
- Team values DX and the Vercel ecosystem (AI SDK, analytics, speed insights)
- Preview deployments and team collaboration are important
Choose Cloudflare Pages if:
- High bandwidth expected or bandwidth cost is a concern
- Lowest possible TTFB is a priority
- Building edge-native applications using Workers, D1, KV, R2
- Cost efficiency at scale is the primary driver
- Applications that would benefit from 300+ PoPs globally
Choose Netlify if:
- Not using Next.js — Gatsby, Hugo, Astro, SvelteKit
- Need built-in form handling or identity
- Prefer credit-based unified billing model
- Need maximum framework flexibility
Verdict
Vercel remains the best platform for serious Next.js development. The native integration with Server Components, ISR, and the Vercel AI SDK is architecturally superior to what other platforms offer. At $20/user, it's the right investment for professional teams.
Cloudflare Pages is the right choice for cost-conscious teams and high-traffic applications. Unlimited bandwidth, 50ms TTFB, and the full Cloudflare Workers ecosystem make it a compelling alternative that many teams underestimate until they see their first bandwidth invoice from Vercel.
Netlify serves teams that need framework flexibility and breadth of built-in features. The credit-based pricing model is more complex to predict, but the platform remains the most framework-agnostic deployment option with the broadest JAMstack ecosystem.
Compare deployment platform pricing, API documentation, and features at APIScout — find the right platform for your application.