# Nuxt hosting in 2026: server-rendered or static, and where to run each

> A Nuxt app is either a Node server that nuxt build makes, or a folder of pages that nuxt generate prerenders, and the host you need follows from which. On Livops the static build is a free site, and the server build runs as a web app for 39 credits a month (39,000 so'm); you choose when you import the repository. Here is how Vercel, Netlify, Cloudflare and Render compare.

Source: https://livops.dev/en/hosting/nuxt-hosting

By Livops team, the people who build and run Livops. Updated 20 November 2026.

Nuxt is two different deployments behind one framework. `nuxt build` makes a Node server that renders pages as they are asked for; `nuxt generate` renders them once, at build time, and leaves files any static host can serve. Which one you have decides what a host has to give you and what it costs. This page covers both with Nuxt's own documentation, compares Vercel, Netlify, Cloudflare and Render with each provider's own numbers, and ends with what Livops runs for each.

## What does a Nuxt app need in production?

### For server rendering: a Node process

Nuxt's server engine is Nitro, and its default output when no preset is set or detected is a Node.js server: `nuxt build` writes `.output/server/index.mjs`, started with `NODE_ENV=production node .output/server/index.mjs`[1][4]. It listens on `NITRO_PORT` or `PORT`, 3000 by default, and on `NITRO_HOST` or `HOST`, `0.0.0.0` by default[1]. Nitro calls the `.output` folder fully standalone[4], and it shuts down gracefully unless `NITRO_SHUTDOWN_DISABLED` is set[4]. On a serverless host, the same build is made with that host's preset instead, and the server becomes a function.

### For a static site: every page found at build time

`nuxt generate` builds the app and prerenders it with Nitro's crawler: by default the root page and every page linked from it, following `<a href>` tags; a page no link reaches is not prerendered[2]. The result is `.output/public`, which any static host can serve[2]. `routeRules` with `prerender: true` adds routes the crawler would miss[2]. With `ssr: false`, `nuxt generate` writes an `index.html` and JavaScript bundles instead, like a classic Vue single-page app[1].

### Configuration at the right time

Nuxt does not read `.env` files in production: variables have to come from the host[3]. And runtime config only picks up variables that start with `NUXT_` in production[3], so `API_SECRET` in the host's settings does nothing where `NUXT_API_SECRET` works. For a static site, every value is fixed at build time.

### Somewhere for server state

A server-rendered Nuxt app that writes files — a cache, an upload, a module's data folder — needs a disk that survives a restart, or a database. A function on a serverless host has neither on its own.

## The options at a glance

| Option | What it is | A static Nuxt site | Smallest paid plan for server rendering | What you still maintain |
| --- | --- | --- | --- | --- |
| Livops | A platform; servers in Uzbekistan | Free | 39 credits (39,000 so'm) a month for one always-on server | Your code |
| Vercel | Functions and a global CDN | Free on Hobby[6] | Pro: $20 a month per developer seat, with $20 of included credit[6] | Your code |
| Netlify | Functions and a CDN, billed in credits | Free plan: 300 credits a month, a hard limit[10] | Personal: $9 a month for 1,000 credits; Pro: $20 for 3,000[9] | Your code |
| Cloudflare Workers | Code at Cloudflare's edge | Static asset requests are free and unlimited[13] | Workers Paid: from $5 a month per account[13] | Your code, within Workers' limits |
| Render | A platform with a native Node runtime | Static sites free[15] | $7 a month: 0.5 CPU, 512 MB[15] | Your code |

Other providers' prices are from each provider's own page, read on 20 November 2026; the dates are in Sources below. Livops prices are the ones the cabinet bills today.

## Each option

### Livops

A Nuxt repository is recognised from `nuxt` in `package.json`, and you choose how it runs when you import it: as finished files, free, or as a server, at the app price (details below). Every `git push` ships a new version. Payment is in so'm through Payme or Click, with no card, and the servers are in Uzbekistan — close to users there, farther from users elsewhere. There is no global CDN of edge locations in front of it, and no root.

### Vercel

Where Vercel is better: Nuxt static and server-rendered sites deploy with no configuration, `nuxt build` is the default, and `routeRules` gives ISR, per-route prerendering and client-side rendering on Vercel's cache and CDN[5]. Server routes, pages and middleware are bundled into one Vercel Function by default, which scales to zero when not in use[5]. `nuxt generate` supports neither SSR nor ISR there[5]. Vercel recommends Nuxt 2 only as a static site[5]. Hobby is free with 100 GB of fast data transfer and 4 hours of Active CPU a month, and a function runs for at most 300 seconds[7]; Pro is $20 a month per developer seat with $20 of included credit, then data transfer from $0.15 per GB after the first 1 TB[6].

### Netlify

Server rendering is supported automatically for Nuxt 3, powered by Nitro; Edge Functions need a different Nitro preset[8]. A synchronous function may run for 60 seconds, a background one 15 minutes[11]. Every production deploy costs 15 credits, bandwidth 20 credits per GB, compute 10 credits per GB-hour and web requests 2 credits per 10,000[10]. Personal is $9 a month for 1,000 credits and Pro $20 for 3,000[9].

### Cloudflare Workers

Cloudflare's guide builds Nuxt with the `cloudflare` preset and serves `.output/server/index.mjs` as the Worker with `.output/public` as its static assets; Wrangler can detect Nuxt and write that configuration itself[12]. Requests to static assets are free and unlimited; the Free plan allows 100,000 requests a day and 10 ms of CPU per request, and Workers Paid starts at $5 a month for 10 million requests[13]. Each isolate has 128 MB of memory[14]. For a mostly static Nuxt site with users on several continents, this is hard to beat on price and distance. What does not fit is work past those limits: more than 128 MB of memory, or more CPU per request than the plan allows.

### Render

Node is one of Render's native runtimes, and static sites are free[15]. A server-rendered Nuxt app runs as a web service from $7 a month for 512 MB[15]. Render takes credit and debit cards[15].

## Functions or a server: what changes?

On Vercel, Netlify and Cloudflare, a server-rendered Nuxt app is cut into functions that start when a request arrives and stop after it; you pay per request and per unit of compute, and the limits are a function's — its duration, its memory, no disk of its own. On Livops or Render it is one long-running `node .output/server/index.mjs`, paid by the month, and the limit is that machine's memory. Websockets, a long request, an in-memory cache and a file written to disk are ordinary on a server; traffic from every continent at once, and paying nothing while nobody visits, are what functions are for.

## Where can you host Nuxt for free?

- **Livops** publishes a static Nuxt site for free, with HTTPS and a livops.app address; the Free plan holds 30 sites and 40 builds a month. A server-rendered app has no free tier; on an account that has not paid yet, the first bot or app runs for 15 minutes on a zero balance, once.
- **Vercel** Hobby is free, with 100 GB of fast data transfer, 4 hours of Active CPU and 100 deployments a day[7].
- **Netlify** Free has 300 credits a month as a hard limit; when they are used up, every project shows "Site not available" until the next cycle[10].
- **Cloudflare Workers** Free allows 100,000 requests a day with 10 ms of CPU each; static asset requests are free[13].
- **Render** serves static sites for free; a free web service spins down after 15 minutes without inbound traffic and takes about a minute to start again, within 750 free instance hours a month per workspace[16].

## Nuxt on Livops

1. Push the repository. In the cabinet, click **New project** and choose it, or upload the folder as a `.zip`.
2. Under **How it runs**, choose **Finished files (static)** or **Runs on the server**. Nuxt is the one framework the form asks about, because its server is built with a different command from its site.
3. Put variables under **Variables**: with the `NUXT_` prefix for runtime config. A static site reads them at build time, so change them and deploy again.
4. Deploy. The log shows the install, the build and, for a server, the start.

Livops makes it a Nuxt project when `nuxt` is in `package.json`. The install is `npm install`, or pnpm, Yarn or Bun when `packageManager` in `package.json` names one; `.nvmrc` or `.node-version` picks the Node version.

**Finished files (static)** — a site, free:

```sh
npm run generate
```

`npx nuxi generate` when there is no `generate` script. `.output/public` is published with HTTPS and a livops.app address; `_redirects` and `_headers` in `public/` work, see [Redirects and headers](https://livops.dev/en/docs/redirects-headers), and [Speed insights](https://livops.dev/en/docs/speed) measure real visitors' LCP and INP. If the build leaves no pages — the app renders everything on request — the deploy stops with `ssr_output`: deploy it as a server.

**Runs on the server** — a web app:

```sh
npm run build
node .output/server/index.mjs
```

`npx nuxi build` when there is no `build` script. What Livops adds:

- **`NITRO_PRESET=node-server`** for the build, unless you set it yourself. If `nuxt.config` names a preset for another host (`cloudflare`, `vercel`), take it out, or the build makes a server Node cannot start.
- **`PORT`** is set, 3000 unless you change it, and Nitro reads it; Nitro already listens on every interface.
- **If the new version does not answer** within a minute, the deploy fails and the version that worked keeps serving; if the build fails, the running version is left alone. Recent versions stay in **Deploys** for a one-click rollback.
- **Files** written under the app's folder, a `.data/` folder included, are gone after a restart or a deploy. Point anything that must be kept at `/app/data` (the `DATA_DIR` variable), or use a database.
- **Memory** is the service's tier: 256, 512, 1024 or 2048 MiB, set with `memory` in `livops.json` when the project is created and in the settings afterwards.

**Nuxt 2** is built with `nuxt generate` into `dist` for a site, and `nuxt build` then `nuxt start` for a server, with `NODE_OPTIONS=--openssl-legacy-provider` so its webpack runs on current Node.

To choose without the form, put `livops.json` in the repository root before the project is created — `"kind": "site"` for the static build, `"web"` for the server:

```json
{
  "kind": "web",
  "memory": 512
}
```

Afterwards the type is changed in the project's settings. A static Nuxt site is **free**; a server-rendered one is **39 credits a month (39,000 so'm)**. One credit is 1,000 so'm, and bought credits never expire. See [Pricing](https://livops.dev/en/docs/pricing) and [Frameworks](https://livops.dev/en/docs/frameworks) for everything `livops.json` accepts.

## Questions

**Static or server, which should I pick for Nuxt?**

Static when every page can be built ahead of time and the app has no server routes it needs at request time: a landing page, docs, a blog. Server when pages depend on who is asking, or the app has server/api routes, sessions or a database. On Livops the first is free and the second is a web app.

**What does Livops run for a static Nuxt site?**

npm run generate, or npx nuxi generate when package.json has no generate script, and publishes .output/public. For Nuxt 2 it is nuxt generate and the dist folder.

**What does Livops run for a server-rendered Nuxt app?**

npm run build, or npx nuxi build, with NITRO_PRESET=node-server unless you set it yourself, and then node .output/server/index.mjs. Nitro reads the PORT the platform gives and listens on every interface. For Nuxt 2 it is nuxt build and nuxt start.

**Why are my environment variables empty in production?**

Nuxt does not read .env files in production, and runtime config only picks up variables that start with NUXT_. Put them under Variables in the cabinet with that prefix, such as NUXT_API_SECRET, and deploy again.

**Can I switch between static and server later?**

The type is changed in the project's settings, and the next deploy builds it the new way. The price follows the type: a server is a web app, billed monthly, and a static site is free.

**How much does Nuxt hosting cost on Livops?**

A static Nuxt site is free. A server-rendered app is 39 credits a month, which is 39,000 so'm at 1,000 so'm a credit. There is no free tier for apps; on an account that has not paid yet, the first app runs for 15 minutes on a zero balance, once. Credits are bought in so'm through Payme or Click, with no card.

**Who wrote this comparison?**

The Livops team. Every price and limit of another provider on this page links to that provider's own page, with the day we read it.

## Sources

1. [Nuxt — Deployment](https://nuxt.com/docs/4.x/getting-started/deployment). Checked 20 November 2026.
2. [Nuxt — Prerendering](https://nuxt.com/docs/4.x/getting-started/prerendering). Checked 20 November 2026.
3. [Nuxt — .env](https://nuxt.com/docs/4.x/directory-structure/env). Checked 20 November 2026.
4. [Nitro — Node.js](https://nitro.build/deploy/node). Checked 20 November 2026.
5. [Vercel — Nuxt on Vercel](https://vercel.com/docs/frameworks/full-stack/nuxt). Checked 20 November 2026.
6. [Vercel — Pricing](https://vercel.com/pricing). Checked 20 November 2026.
7. [Vercel — Hobby plan](https://vercel.com/docs/plans/hobby). Checked 20 November 2026.
8. [Netlify — Nuxt on Netlify](https://docs.netlify.com/build/frameworks/framework-setup-guides/nuxt/). Checked 20 November 2026.
9. [Netlify — Pricing](https://www.netlify.com/pricing/). Checked 20 November 2026.
10. [Netlify — How credits work](https://docs.netlify.com/manage/accounts-and-billing/billing/billing-for-credit-based-plans/how-credits-work/). Checked 20 November 2026.
11. [Netlify — Configuration for functions](https://docs.netlify.com/build/functions/configuration/). Checked 20 November 2026.
12. [Cloudflare — Nuxt on Workers](https://developers.cloudflare.com/workers/framework-guides/web-apps/more-web-frameworks/nuxt/). Checked 20 November 2026.
13. [Cloudflare — Workers pricing](https://developers.cloudflare.com/workers/platform/pricing/). Checked 20 November 2026.
14. [Cloudflare — Workers limits](https://developers.cloudflare.com/workers/platform/limits/). Checked 20 November 2026.
15. [Render — Pricing](https://render.com/pricing). Checked 20 November 2026.
16. [Render — Deploy for free](https://render.com/docs/free). Checked 20 November 2026.
