Best CMS for Nuxt in 2026

Nuxt gives you three ways to render a page — server-side (SSR), statically generated (SSG), or hybrid via Nitro's route rules. Your CMS choice has to survive all three. A CMS that works great in dev SSR but chokes when you pre-render 2,000 routes at build time isn't the right pick, no matter how nice its editor is.

So this isn't a generic "best CMS" list. It's a render-mode-first picker for Nuxt in 2026 — eight options sorted by how they fit Nuxt's data-fetching model, what they cost, and who's editing the content. Nuxt is framework-agnostic about where content comes from; any of these works. The question is which one fits your render mode, budget, and team.

TL;DR — the fast picks

• Official Nuxt module + visual editing → Storyblok
• Open source, self-hosted, you run the infra → Strapi
• Self-hosted, modern admin, paid once (no monthly bill) → UnfoldCMS
• Editor team at scale, great authoring DX → Sanity
• Enterprise, heavy governance → Contentful
• Markdown in your repo, no backend → Nuxt Content
• Git-based, developer-run → Directus (self-host) or a flat-file setup
• All-in-one hosted with Nuxt-friendly APIs → Hygraph

First: pick your render mode, then your CMS

Nuxt's rendering decides which CMS traits matter.

• SSG (nuxt generate) — every page is built once. You need a CMS whose API is fast and paginated for build-time fetches, and ideally webhooks so a content edit can trigger a fresh build. Content freshness = rebuild frequency.
• SSR (Nitro server) — pages render on request. The CMS API gets hit at runtime, so latency and caching matter. Editors see changes instantly, no rebuild.
• Hybrid (route rules) — mix per route (routeRules). Marketing pages pre-rendered, blog SSR, dashboard SPA. You want a CMS that's comfortable being called both at build and at runtime.

Almost every CMS below can do all three. Where they differ is the rebuild-on-publish story (SSG) and the runtime latency story (SSR). Keep that in mind as you read.

1. Storyblok — the official Nuxt integration

Best for: teams that want visual editing and a first-party Nuxt module.

Storyblok has an official @storyblok/nuxt module and a visual editor that renders your actual Nuxt components in a live preview. Editors click a block on the page and edit it in place — that's the big draw. For marketing teams who want to see what they're editing, it's the smoothest option here.

It's a hosted SaaS with a free tier and paid plans that scale by usage/seats. The visual editor is the reason to pick it; if your team doesn't need in-context editing, you're paying for a feature you won't use.

2. Strapi — open source, self-hosted

Best for: teams that want to own the backend and don't mind running it.

Strapi is the default answer for "open-source headless CMS." You self-host a Node.js app, model your content types in its admin, and consume the REST or GraphQL API from Nuxt. No per-seat SaaS bill — you pay for the server you run it on. The content-type builder is flexible, the plugin ecosystem is real, and you keep full control of the data.

The cost is operational: you're maintaining a Node service, its database, upgrades, and backups. That's fine if you already run infrastructure, a real burden if you don't.

3. UnfoldCMS — self-hosted, modern admin, one-time price

Best for: teams that want a polished self-hosted CMS without a recurring bill or a Node backend to babysit.

UnfoldCMS is a PHP/Laravel CMS with a React + shadcn/ui admin. For a Nuxt front end it's purely a content source: you read its REST API at /api/v1/* — posts, pages, categories, search, menus — with plain fetch() inside a Nuxt useAsyncData call. There are no official npm SDKs; you hit the JSON endpoints directly.

Two things make it fit Nuxt well. First, outgoing HMAC-signed webhooks: on publish, UnfoldCMS can POST to a rebuild hook, so an SSG Nuxt site regenerates automatically when an editor publishes. Second, the one-time license — you self-host and the bill doesn't recur, unlike the SaaS options above.

// nuxt: fetch a page from UnfoldCMS at build or runtime
const { data: page } = await useAsyncData('page', () =>
  $fetch('https://your-cms.com/api/v1/pages/about')
)

Honest limits: it runs on PHP 8.3+, so you're hosting a PHP app (not Node) as your content backend. No content revisions, no built-in multi-language content (template UI strings only). If you need per-locale content or approval workflows, this isn't the pick.

4. Sanity — best authoring DX for editor teams

Best for: teams with dedicated editors who spend all day in the CMS.

Sanity's Studio is the nicest authoring experience in this list. Real-time collaboration, structured content, a customizable editing environment, and GROQ (its query language) for precise data fetching. For a content team producing a lot of structured articles, editors genuinely prefer it.

It's a hosted SaaS billed on usage (API requests, seats, bandwidth). Costs are predictable at small scale and climb as you grow. If your differentiator is editor happiness at scale, Sanity earns the spend. For a mostly-static marketing site, it's more than you need.

5. Contentful — enterprise and governance

Best for: larger orgs that need roles, environments, and compliance.

Contentful is the enterprise-grade option: content environments (staging vs prod), granular roles and permissions, localization, and a mature ecosystem. It's the safe pick when procurement and governance matter more than price. It has Nuxt-friendly REST and GraphQL APIs.

The tradeoff is cost — it's the most expensive category here once you're past the free tier — and it's more machinery than a small team needs.

6. Nuxt Content — Markdown in your repo, no backend at all

Best for: developer-run sites where content is Markdown and lives in Git.

Nuxt Content is a first-party Nuxt module that turns Markdown/YAML/JSON files in your repo into a queryable content source. There's no external CMS, no API, no monthly bill — content is files, versioned in Git, deployed with your code. For a docs site, a developer blog, or a small marketing site run entirely by developers, it's the simplest possible answer.

The limit is obvious: there's no editor UI for non-technical people. Publishing means a commit and a deploy. If an editor needs to publish without touching Git, Nuxt Content isn't it — reach for a real CMS above.

7 & 8. Directus and Hygraph — the runners-up

Directus wraps any SQL database in an instant REST + GraphQL API and a clean admin. Self-hostable (open source) or cloud. Good when you want to expose an existing database to Nuxt with minimal glue.

Hygraph (formerly GraphCMS) is a hosted, GraphQL-native headless CMS. If your Nuxt app is already GraphQL-first, its API model fits naturally. Usage-based pricing.

Nuxt CMS comparison — 2026

Which should you pick for Nuxt?

• Marketing team that wants to see edits live → Storyblok (official module).
• You run infra and want open source → Strapi.
• You want a modern self-hosted admin and hate monthly bills → UnfoldCMS. The rebuild webhook makes SSG painless.
• Editor-heavy team → Sanity.
• Enterprise governance → Contentful.
• Content is Markdown and you're all developers → Nuxt Content. Don't add a CMS you don't need.

FAQ

What's the best CMS for a static (SSG) Nuxt site?

For nuxt generate you want a CMS with a fast paginated API and rebuild webhooks, so publishing triggers a fresh build. UnfoldCMS, Storyblok, Strapi, and the SaaS options all fire webhooks on publish. If your team is all developers, Nuxt Content skips the API entirely — content is files built with the site.

Can I use a PHP CMS with Nuxt?

Yes. Nuxt doesn't care what language your CMS is written in — it only consumes an API. UnfoldCMS is PHP/Laravel and exposes a REST API at /api/v1/* that Nuxt reads with $fetch/useAsyncData. See the UnfoldCMS + Nuxt integration guide for the wiring.

Do I need an npm SDK to connect a CMS to Nuxt?

No. Some CMSes ship SDKs (Storyblok, Sanity) for convenience, but every one here can be consumed with plain $fetch/fetch. UnfoldCMS has no official SDK — you call its JSON endpoints directly, which is often less code than pulling in a client library.

Storyblok vs Strapi for Nuxt?

Storyblok if you want the official module and visual in-context editing without running servers. Strapi if you want to self-host, own your data, and avoid per-seat SaaS pricing. Storyblok is easier to start; Strapi gives you control and no recurring license.

How do I trigger a rebuild when content changes?

Point your host's deploy hook (Vercel, Netlify, Cloudflare Pages) at the CMS's outgoing webhook. UnfoldCMS sends HMAC-signed POSTs on publish/update; verify the signature in a small serverless function, then hit your build hook. That keeps an SSG Nuxt site fresh without manual redeploys.

Building the front end next? Read the UnfoldCMS + Nuxt integration guide, or check the pricing if the one-time self-hosted model fits your team.