Next.js Hosting Cost 2026: Vercel vs Self-Hosted VPS

Plug in three numbers and you have your real Next.js hosting cost: how many developers deploy, how many GB you serve a month, and whether you need analytics, error tracking and session replay. Next.js itself is free (MIT-licensed); you pay for hosting. Costs run from $0 (Vercel Hobby for non-commercial projects, Cloudflare's free tier) to about $100/month for a 5-developer team on Vercel Pro at 100K monthly active users, and about $729/month for the same team at 1M. A self-hosted server costs a flat amount: a Hetzner CX23 (2 vCPU, 4 GB RAM, 20 TB of traffic) is €5.49/month excluding VAT (verified 2026-10-07), and Temps runs on it for free with deployments, analytics, error tracking and session replay included. Prefer sliders? Use the interactive PaaS Tax Calculator.

Next.js hosting cost by platform (2026)

Prices checked on each vendor's pricing page in October 2026. For Vercel's plans, limits and add-ons in full, see Vercel pricing 2026.

The worksheet. Copy it and fill in the blanks:

team_size      = ___ developers who deploy
monthly_gb     = ___ GB served per month (check your analytics)
observability  = yes / no (analytics + error tracking + session replay)

Vercel Pro   = ($20 x team_size)
             + max(0, (monthly_gb - 1000) x $0.15 + other_usage - $20 credit)
             + (observability ? $211 : $0)
Self-hosted  = server price, flat (e.g. Hetzner CX23 €5.49/mo or CX33 €8.49/mo, excl. VAT)
Temps        = $0 on that same server; observability included

other_usage is compute, invocations, edge requests and builds, about $15 a month for a 5-developer team at 100K monthly active users. The $211 observability line is the entry price of Plausible Starter ($9), Sentry Team ($26) and LogRocket (from $176); drop LogRocket and it is $35.

Worked example 1 (5-person team, 1,500 GB a month, observability needed):

Vercel Pro  = $100 + max(0, 500 x $0.15 + $15 - $20) + $211 = $100 + $70 + $211 = $381/mo
Self-hosted = Hetzner CX33, €8.49/mo excl. VAT (4 vCPU, 8 GB, 20 TB traffic)
Temps       = $0 on that server, observability included

Worked example 2 (solo developer, 300 GB a month, observability needed):

Vercel Pro  = $20 + $0 (usage inside the credit) + $211 = $231/mo
Self-hosted = Hetzner CX23, €5.49/mo excl. VAT
Temps       = $0 on that server, observability included

Vercel's bill grows with team_size and monthly_gb; a self-hosted bill only grows when you need a bigger server.

TL;DR: Next.js is free. A 5-person team on Vercel Pro pays about $100/month at 100K monthly active users and about $729/month at 1M, before observability tools (about $211/month at entry prices). Self-hosting runs on a flat-priced server, such as a Hetzner CX23 at €5.49/month excluding VAT, and a self-hosted PaaS like Temps adds deployments, analytics, error tracking and session replay at no extra cost.

Why Are Next.js Hosting Costs So Unpredictable?

Per-seat pricing and usage overage make managed Next.js bills hard to forecast. Vercel Pro is a $20/month platform fee that includes one deploying seat and $20 of usage credit, with $20 for each extra deploying seat and data transfer past 1 TB from $0.15/GB. A team that stays inside the allowances pays a predictable amount; a viral post can move the bill overnight.

That is the structural problem with usage-based pricing: when your site gets popular, your bill grows with it. New Vercel Pro teams get a default $200 on-demand budget alert, but it only notifies you; production keeps serving and billing unless you turn on a hard limit.

The hosting platform is also rarely the whole bill. A real comparison includes:

• Seats (every developer who deploys)
• Bandwidth and data transfer (especially for image-heavy sites)
• Serverless compute (API routes, SSR pages)
• Builds (CI/CD time, including preview deployments)
• Add-on services (analytics, monitoring, error tracking, session replay)

How Much Does Vercel Cost for Next.js in 2026?

Vercel Pro is a $20/month platform fee that includes one deploying seat and $20 of usage credit; each extra deploying seat is $20/month and viewer seats are free. Data transfer past the included 1 TB costs from $0.15/GB. For a solo developer on Hobby (non-commercial only), it's $0.

Base costs:

Usage rates (Pro):

• Data transfer: from $0.15/GB after 1 TB
• Edge requests: $2 per million after 10M
• Builds: $0.0035 per CPU-minute on Elastic machines (the default for new Pro teams since April 2026); fixed Standard machines are $0.014/min and Turbo $0.105/min
• Function compute: from $0.128 per active CPU-hour, plus provisioned memory
• Function invocations: $0.60 per million

Example: 5-person team, 200 GB, 500K function invocations

Platform fee + 4 extra seats: $100
Usage (transfer inside 1 TB, a few dollars of compute and builds): covered by the $20 credit
Total: $100/month

Example: 5-person team, 2 TB, 10M function invocations

Platform fee + 4 extra seats: $100
Transfer: 1,000 GB over x $0.15 = $150
Invocations: 10M x $0.60/M = $6
Compute and builds: ~$15
Credit: -$20
Total: ~$251/month

The worked bills at 10K, 100K and 1M monthly active users, with every line item, are in the Vercel pricing guide.

What the formula leaves out is observability. Analytics is Plausible from $9/month, error tracking is Sentry Team at $26/month, and session replay is LogRocket from $176/month. For many production apps those add-ons cost more than the hosting.

What Does Self-Hosted Next.js Actually Cost?

Self-hosting runs on a server with a flat monthly price. On Hetzner Cloud, a CX23 (2 vCPU, 4 GB RAM, 40 GB NVMe, 20 TB of traffic) is €5.49/month excluding VAT, a CX33 (4 vCPU, 8 GB) €8.49 and a CX43 (8 vCPU, 16 GB) €15.99, per Hetzner's cloud pricing (verified 2026-10-07; CX plans are offered in Germany and Finland only). There are no per-seat fees and no transfer overage until you pass the server's 20 TB.

Server costs (DigitalOcean vs Hetzner):

Additional costs:

• TLS certificates: free (Let's Encrypt)
• Monitoring: included in a self-hosted PaaS like Temps, or a separate service
• CI/CD: free tiers on GitHub Actions, or builds on the server itself

Costs you shouldn't ignore:

• Your time running the server (significant for teams without ops experience)
• Incident response and on-call
• Security patching and OS updates

Formula:

Monthly cost = server_cost + managed_services + (ops_hours x hourly_rate)

Ops time is the wild card. If your team already runs servers, self-hosting is straightforward. If not, that cheap server can cost more in engineering hours than Vercel would.

How Does Railway Compare on Price?

Railway has no per-seat fees on any plan. Hobby is $5/month including $5 of usage; Pro, the plan a team needs, is $20/month per workspace with unlimited seats and $20 of usage included, per Railway's pricing page. Usage beyond the included credit is billed on top.

Usage rates:

• vCPU: about $20 per vCPU-month
• Memory: about $10 per GB-month
• Egress: $0.05/GB

Formula:

Monthly cost = plan fee + max(0, (vcpu_months x $20) + (gb_ram_months x $10) + (egress_gb x $0.05) - included credit)

Example: Next.js app with Postgres, both running at full allocation all month

App: 1 vCPU, 2 GB RAM = ~$40
Database: 0.5 vCPU, 1 GB RAM = ~$20
Egress: ~$0 at low traffic
Usage: ~$60 → on Pro, $20 fee covers the first $20, so ~$60/month total

Railway bills measured utilisation, so an app that idles most of the day costs less than this ceiling. It sits between self-hosting and Vercel: simpler than running a server, cheaper than Vercel for multi-developer teams, but without built-in analytics or error tracking. For worked bills, see Railway pricing 2026.

What About Cloudflare Pages?

Cloudflare serves static assets free and without limit on every plan, which makes it the cheapest option for static-heavy sites. Dynamic code, including server-rendered Next.js, runs on Workers, which is where the limits and costs are. The full list is in Cloudflare Pages free tier limits.

Pricing:

Formula:

Monthly cost = $0 (static, or under 100K dynamic requests/day)
             or $5 + max(0, requests - 10M) x $0.30/M + CPU overage

The catch is Next.js support. Server-rendered Next.js on Cloudflare runs on Workers through vinext, Cloudflare's recommended default (in beta), or the OpenNext adapter, within Workers' CPU and 128 MB memory limits. For static-first sites it's hard to beat free, unlimited static bandwidth.

How Do Costs Compare Side by Side?

These scenarios use the Vercel bills from the Vercel pricing guide, which assume about 3 page views per user a month and 1.5 MB per page.

Scenario 1: Solo Developer, Side Project

Specs: 1 developer, 10K monthly active users

Winner: Vercel Hobby or Cloudflare for non-commercial projects. A commercial project needs Vercel Pro or another host.

Scenario 2: Startup Team, Growing SaaS

Specs: 5 developers, 100K monthly active users, ~450 GB a month

Winner: self-hosted, if someone on the team is comfortable running a server.

Scenario 3: Established Company, High Traffic

Specs: 20 developers, 1M monthly active users, ~4.5 TB a month, needs analytics, error tracking and session replay

Winner: self-hosted with a PaaS layer, provided the team can run it. Size the server to your real load; at this traffic you may want two servers.

Scenario 4: Enterprise

Specs: large team, compliance requirements, negotiated contract

Vercel Enterprise has no public price; Vendr reports a median contract of $52,825 a year. Self-hosted Temps costs your servers plus, if you need SAML SSO, SCIM or a tamper-evident audit log, a Premium licence at $399/organisation/month. Temps doesn't hold SOC 2 or HIPAA certifications, so teams that need a vendor with them should look at Vercel Enterprise.

How Much Do Vercel Preview Deployments Cost?

Preview deployments, a unique URL for every pull request, are one of Vercel's best features, and a hidden cost multiplier: every preview runs a build and serves traffic from your Pro usage.

The math:

preview_cost = builds_per_month x build_minutes x vCPUs x $0.0035 + preview_bandwidth

A team of 5 pushing 10 PRs a day with 3-minute builds:

Build minutes: 10 PRs x 3 min x 30 days = 900 min/month
On a 4-vCPU Elastic machine: 3,600 CPU-min x $0.0035 = ~$12.60/month
On Turbo (30 vCPU, opt-in): 900 x $0.105 = ~$94.50/month

Previews have no separate charge on Pro, but their builds draw on usage, and the machine size is what decides the bill.

Self-hosted alternative: Temps gives you the same workflow, a preview environment per branch or pull request, on your own server, and removes it when the branch is deleted. Builds run on your server, so there is no per-minute charge.

How Much Does Next.js Deployment Cost for Large Projects?

Running many Next.js apps (agencies with client sites, or companies with several teams) is where cost structures diverge most.

Illustrative example: 50 Next.js sites, 20 developers

Vercel's seat fees are $400/month for 20 developers whatever the number of sites, and every project adds its own transfer, builds and any per-project add-ons. On your own servers, the 51st site costs nothing extra until you need more capacity.

What Is the "Vercel Tax" and Is It Worth Paying?

Vercel's pricing buys things that are genuinely hard to replicate:

1. No infrastructure to run: Vercel handles servers, scaling and the network
2. Global edge network: content served close to every user
3. First-party Next.js integration: new Next.js features work on day one
4. Preview deployments: every PR gets a unique URL
5. Analytics: Web Analytics and Speed Insights (at extra cost)

For teams without anyone to run servers who value convenience above all, it is worth it. For teams with even one person comfortable running a server, the math rarely favours Vercel past the free tier.

The Vercel pricing model creates a squeezed middle: Hobby is free for non-commercial work, Enterprise gets negotiated rates, and growing teams on Pro pay list price for seats and usage.

How Do You Calculate Your True Next.js Hosting Cost?

Five steps:

Step 1: Count Your Team

team_cost = deploying_developers x $20 (Vercel Pro; viewers are free)
team_cost = $0 (self-hosted)

Step 2: Estimate Bandwidth

Average page weight x monthly page views = bandwidth
Example: 2 MB x 100,000 page views = 200 GB

Step 3: Count Function Invocations

Dynamic requests per page view x monthly page views = invocations
Example: 5 x 100,000 = 500,000 invocations

Step 4: Add Your Observability Stack

Some self-hosted PaaS options include these at no extra charge. On Vercel, you pay for each one separately.

Total cost of ownership: 5-person team, 100K monthly active users

Switching that Vercel stack to Temps on a Hetzner CX23 removes about $300 a month in subscriptions, in exchange for running the server yourself.

Step 5: Sum It Up

Vercel total:      team_cost + max(0, usage - $20 credit) + observability
Self-hosted total: server_cost (+ observability, unless your platform includes it)

What Can We Learn from Real-World Cost Comparisons?

37signals' cloud exit is the best-known example: its annual cloud bill fell from $3.2M to $1.3M in 2024, and it expects the move to save well over $10M over five years (DHH). That is a different scale from a Next.js team, but the pattern, renting a fixed amount of hardware instead of paying per unit of usage, is the same.

The two profiles below are illustrative, built from published prices rather than customer data.

Illustrative Profile A: E-commerce Site

Before (Vercel + third-party tools):

• 8 developers: $160/mo (Vercel Pro platform fee + 7 extra seats)
• 1.5 TB of transfer: $75/mo overage, less the $20 credit
• Sentry Business: $80/mo
• Plausible Business: $19/mo
• Total: ~$314/mo

After (self-hosted PaaS on Hetzner):

• Hetzner CX33 (4 vCPU, 8 GB): €8.49/mo excl. VAT
• Error tracking, analytics, monitoring: included
• Total: €8.49/mo

Illustrative Profile B: SaaS Dashboard

Before (Vercel + observability stack):

• 3 developers: $60/mo
• Usage inside the credit: $0
• LogRocket Core: $176/mo
• Sentry Team: $26/mo
• UptimeRobot Solo: ~$10/mo
• Total: ~$272/mo

After (self-hosted PaaS):

• Hetzner CX23 (2 vCPU, 4 GB): €5.49/mo excl. VAT
• Session replay, errors, uptime monitoring: included
• Total: €5.49/mo

In both profiles most of the saving is the observability subscriptions, not the hosting. The trade-off is operational: neither team has 37signals' dedicated ops staff, so someone has to own the server.

Which Platform Should You Choose?

The right choice depends on your team's capacity to run infrastructure, not only your budget.

For deploy commands and trade-offs per option, see 5 ways to deploy a Next.js app.

How Do You Self-Host a Next.js App with Analytics?

Use a self-hosted PaaS that includes observability. The usual do-it-yourself route is:

1. Provision a server
2. Install Docker
3. Set up a reverse proxy and TLS
4. Run Plausible for analytics
5. Add Sentry for errors
6. Connect LogRocket for session replay

That is several services and subscriptions to maintain. With Temps it is two steps:

# On your server: install Temps
curl -fsSL https://temps.sh/deploy.sh | bash

# From your project: log in and deploy
bunx @temps-sdk/cli login https://console.203-0-113-1.sslip.io
bunx @temps-sdk/cli deploy --project my-app -e production

Temps is an open-source self-hosted PaaS written in Rust. It includes:

• Web analytics: page views, sessions, referrers and funnels
• Error tracking: stack traces and error grouping through a Sentry-compatible DSN
• Session replay: off by default; records the page and user input, with inputs masked
• Uptime monitoring: monitors with alerts by email, Slack or webhook
• Git-push deployments: the same workflow as Vercel, on your server
• Preview environments: a URL per branch or pull request
• Managed databases: Postgres, Redis, MongoDB and S3-compatible storage

It replaces seven SaaS tools (Vercel, PostHog, Sentry, Pingdom, Datadog, Resend and E2B), is free to self-host under MIT / Apache 2.0, and has no per-seat or bandwidth fees. Temps Cloud, a hosted control plane for your own servers, is coming soon from $29/month. Traffic goes through Pingora, the Rust proxy framework Cloudflare built, with TLS and routing handled for you.

Getting started:

The full walkthrough is in Deploy Next.js to your own server.

Next.js Pricing Explained

Next.js has no pricing. It's MIT-licensed open-source software maintained by Vercel; you pay for the infrastructure to run it.

The confusion comes from Next.js being Vercel's framework, which makes Vercel's hosting the default path. So "Next.js pricing" in practice means hosting pricing:

The framework is free in every row. The differences are the infrastructure model, observability and who runs the servers.

Frequently Asked Questions

What is the cheapest way to host a Next.js app in 2026?

A small VPS running a self-hosted PaaS. A Hetzner CX23 (2 vCPU, 4 GB RAM, 20 TB of traffic) is €5.49/month excluding VAT (verified 2026-10-07), and Temps runs on it for free with git-push deploys, analytics, error tracking and session replay, so you don't pay for Plausible, Sentry or LogRocket on top. A bare server with Nginx and Docker costs the same but leaves those tools to buy separately. Cloudflare is free for static sites but runs server-rendered Next.js on Workers with tight limits, and Vercel Hobby is free only for non-commercial projects.

How do I estimate my monthly Next.js hosting bill?

Use the worksheet at the top of this guide: team size, monthly bandwidth in GB, and whether you need observability. For Vercel Pro, that is $20 per deploying developer, plus transfer past 1 TB at $0.15/GB and other usage beyond the $20 credit, plus about $211/month if you buy analytics, error tracking and session replay separately. Self-hosting is the flat price of your server. For an interactive version, use the PaaS Tax Calculator.

What is Next.js pricing in 2026?

Next.js itself is free, MIT-licensed open-source software. "Next.js pricing" means the cost of hosting it: $0 on Vercel Hobby (non-commercial) or Cloudflare's free tier, about $100/month for a 5-developer team on Vercel Pro at 100K monthly active users, $5–$20/month plus usage on Railway, or a flat server price when self-hosting (from €5.49/month excluding VAT on a Hetzner CX23).

How much does Vercel cost for a team of 5?

About $100/month: the $20 Pro platform fee covers one deploying seat and four more cost $20 each, and at 100K monthly active users usage stays inside the $20 credit. At 1M monthly active users, transfer overage brings it to about $729/month. Analytics, error tracking and session replay tools add about $211/month at entry prices.

Is Vercel worth it for large projects?

For 20 developers, Vercel Pro's seat fees alone are $400/month, and at 1M monthly active users the bill is about $1,029/month before observability tools. Self-hosted alternatives give a comparable deployment workflow for the price of the servers, but someone has to run them. Vercel is strongest for teams with no infrastructure capacity that want previews and a global network with no setup.

How much do Vercel preview deployments cost?

Previews have no separate charge on Pro, but their builds and traffic draw on usage. A team pushing 10 PRs a day with 3-minute builds runs about 900 build minutes a month: about $12.60 on a 4-vCPU Elastic machine, or $94.50 on Turbo. Self-hosted platforms run the same preview workflow on your server with no per-minute charge.

Start Calculating Your Real Costs

Before choosing a Next.js host, run the worksheet with your real numbers: deploying developers, bandwidth, function invocations and the observability tools you need. Or model it interactively with the PaaS Tax Calculator.

# Try self-hosted deployment
curl -fsSL https://temps.sh/deploy.sh | bash
bunx @temps-sdk/cli deploy --project my-app -e production

Related guides:

• Deploy Next.js Without Vercel: the options compared, with deploy commands
• How to Migrate from Vercel to Self-Hosted: step-by-step migration if you've decided to switch
• Vercel Pricing 2026: every plan, add-on and hidden cost
• Cheapest Vercel Pro alternative: managed options without per-seat fees
• Temps vs Coolify vs Netlify: self-hosted platform comparison
• 10 Vercel Alternatives for Next.js: if you've decided to move, here are your options