Best CMS for Next.js

Next.js powers more new content sites in 2026 than any other React framework. Pick the wrong CMS and you'll spend more time wrestling with rate limits, GROQ queries, or webhook revalidation than actually building features. This page is a developer-honest breakdown of the eight CMSes that actually fit Next.js — what they cost, where they break, and which one fits which kind of project.

TL;DR: For most Next.js sites, three options are in the realistic shortlist: Sanity (powerful Studio, expensive at scale), Payload (TypeScript-native, self-hosted, Node), and UnfoldCMS (one-time license, full Laravel CMS that you can decouple — official headless API on the roadmap). Contentful is overpriced for what it gives a Next.js team. WordPress works as a headless source but the DX is rough. Strapi works but ops overhead is real. Pick by deployment model and pricing — not by feature checklist alone.

Quick Comparison: 8 CMS Options for Next.js

What Makes a CMS Actually Work With Next.js

The Next.js–CMS interface has four moving parts that determine real-world DX. Get any of them wrong and the partnership breaks down.

1. Data fetching pattern. Next.js 15's App Router defaults to React Server Components fetching directly. Your CMS needs a fast, type-safe SDK or REST/GraphQL API that works inside RSC without a hydration mismatch. CMSes with Local APIs (Payload) skip the network round trip entirely.

2. Incremental Static Regeneration (ISR) and revalidation. When content changes, your CMS needs to fire a webhook that triggers Next.js to revalidate specific paths or tags. Without this, you ship stale content for hours. Sanity, Contentful, and Hygraph have first-class webhook revalidation. Self-hosted CMSes need you to wire it yourself — typically a 10-line API route.

3. Preview mode. Editors expect to see drafts before publishing. Next.js has Draft Mode (formerly Preview Mode); your CMS needs to issue draft tokens and your frontend needs to switch query modes when draft cookies are set. Payload's Live Preview and Sanity's Visual Editing are the gold standard. Most others require manual wiring.

4. Image handling. Next.js's <Image> component expects predictable URLs and loaders. CMSes with built-in image pipelines (Sanity, Storyblok) integrate via custom loaders. Self-hosted CMSes typically need Cloudflare Images or imgproxy in front to match.

If a CMS doesn't handle these four cleanly, you'll spend the first month of any project building plumbing instead of features.

The Honest Shortlist

Out of the eight options in the table above, three are realistic for most teams. The rest are situational.

1. UnfoldCMS — Best for Agencies and Content Sites

Pricing: $39 (Core), $99 (Pro), $349 (Business, 5 sites), $799 (Agency, unlimited). One-time. No usage metering, no per-seat pricing.

Stack: Laravel 12 + MySQL. Admin is built on shadcn/ui — 50 components, 183 admin pages, Tailwind v4, three switchable themes. See also: shadcn/ui CMS.

Next.js DX (today): UnfoldCMS is currently a full-stack Laravel CMS — it ships with its own themed frontend rather than a public headless API. Using it as a content backend for Next.js today means writing a thin Laravel route in your CMS that exposes the data you want (blog posts, pages, settings) and fetching from that endpoint inside a Server Component. Laravel makes this a 5-line controller. We've seen developers do it on real projects.

What's coming: A first-class headless mode is on the roadmap — official public REST + GraphQL endpoints for posts, pages, and settings; signed webhooks on content changes; draft-preview tokens; and a @unfoldcms/next SDK with revalidateTag helpers. Until that ships, treat UnfoldCMS as a "Laravel CMS you can decouple" rather than a turnkey headless source.

Where it wins for Next.js: One-time pricing, no API metering means preview deploys never burn budget. Includes a themed frontend if you want to ship a marketing site without building one in Next.js — many teams use the themed frontend for the marketing site and Next.js for the app, sharing the same database. Built-in SEO records, redirects, comments, and forms.

Where it loses today: No turnkey public API yet — you write your own thin Laravel routes for the data you need. No real-time multi-cursor editing. No hosted CDN out of the box (pair with Cloudflare). Smaller ecosystem than WordPress or Sanity.

Pick if: You're an agency running multiple Next.js client sites, a SaaS founder building marketing pages, or a team that wants predictable one-time pricing instead of monthly bills that scale with traffic.

See UnfoldCMS pricing → | Live demo →

2. Sanity — Best for Design-Led Teams

Pricing: Free tier (3 users, 10k documents), Growth at $99/month per project, Enterprise custom-quoted. API requests are metered and overages bill at $1 per 100k requests. Real-world Next.js sites typically hit 2–5M API requests/month, especially with preview deploys.

Stack: Hosted document store + customizable React Studio. Query language is GROQ (Sanity-specific), with GraphQL also available. The Studio is open source and self-hostable; the document store is managed.

Next.js DX: Excellent. The official @sanity/client and next-sanity packages handle ISR, webhook revalidation, draft mode, and visual editing out of the box. The live API for real-time content streaming is class-leading.

Where it wins: Real-time collaborative editing (live cursors, presence). Visual editing inside the Next.js page (click a text element in your live site, edit it in Sanity). Mature image pipeline with hotspots and on-the-fly transforms.

Where it loses: Pricing scales fast. Per-project model — agencies running 10 Next.js sites pay 10× $99/month. GROQ has a learning curve unique to Sanity. We covered the cost reality in UnfoldCMS vs Sanity.

Pick if: You have multiple editors collaborating on the same documents in real-time as a daily workflow, you're a design-led team where the editorial UI is part of the product, or you have budget for $200–$2,000/month in CMS infrastructure.

3. Payload CMS — Best for TypeScript-Only Node Teams

Pricing: Free under MIT (self-host the OSS core forever). Payload Cloud starts at $35/month per project on Standard. Enterprise is custom.

Stack: Node + TypeScript + Next.js (the admin runs as a Next.js app). Database is your choice of PostgreSQL, MongoDB, or SQLite. Config-as-code — collections, fields, access rules all live in TypeScript files.

Next.js DX: Excellent. Payload 3.0 is built on Next.js, so the Local API runs in-process for Server Components — no HTTP round trip, no rate limits, no API keys for server-side queries. Type inference flows from collection config to API response.

Where it wins: End-to-end type safety. Local API is faster than any HTTP-based CMS. Live Preview and Visual Editing are built in. Backed by Figma (acquired in 2025) for funding stability.

Where it loses: Headless only — you build the frontend yourself, no included themes. Operating Payload at scale means owning the Node deploy, Postgres/Mongo cluster, backups, and patching. We covered the trade-offs in UnfoldCMS vs Payload CMS.

Pick if: Your stack is Node + Next.js + TypeScript, your team operates Docker and Node infrastructure already, and config-as-code with every schema change in git is a hard requirement.

The Situational Options

These five aren't wrong for Next.js — they're just narrower fits.

Contentful: Mature, polished, expensive. Starts at $300/month per space and scales to $5,000+/month. Pick only if you're a large enterprise that already has the budget approved and needs Salesforce/Shopify integrations. For most Next.js teams, the pricing math doesn't work.

Strapi: OSS Node CMS, similar value prop to Payload but with a less polished admin and a more plugin-driven ecosystem. Strapi Cloud at $99/month per project competes with Sanity Growth. Pick if you want OSS-first and prefer Strapi's admin philosophy to Payload's.

Storyblok: Visual editor is genuinely strong if your editors live in WYSIWYG mode. Pricing starts at $99/month. Best for marketing teams where the visual builder is the killer feature; weaker for structured content.

Hygraph: GraphQL-only CMS, fast and well-typed. Starts at $79/month. Pick if your team is GraphQL-native and you want zero REST. Limited frontend renderer means you're always building Next.js separately.

WordPress (headless): Free if you ignore plugin licenses, but the DX is rough. WPGraphQL works but you'll fight GraphQL schema mismatches with custom field plugins. Pick only if you have an existing WordPress content team that won't migrate. We unpack this in UnfoldCMS vs WordPress.

Decision Framework

Pick by team and project shape — not by feature count.

Choose UnfoldCMS for Next.js if:

• You're building marketing sites, blogs, or content properties (not custom apps with bespoke editorial workflows)
• You want one-time pricing instead of monthly bills that scale with traffic
• You're OK writing a small Laravel route to expose the data you need today (a turnkey headless API is coming, not shipped yet)
• Your team is Laravel-friendly or just wants a CMS that runs on cheap PHP hosting alongside your Next.js Vercel deploy

Choose Sanity if:

• Multiple editors collaborate on the same document in real time, daily
• Visual editing inside the live site is a hard requirement
• Budget is approved for $200–$2,000/month in CMS spend

Choose Payload if:

• Your stack is 100% Node + TypeScript and you want end-to-end type safety
• Config-as-code is non-negotiable
• Your team owns Docker, Node deploys, and managed databases

For everything else, the situational options above might fit — but for most teams shipping a Next.js content site in 2026, the realistic choice is between these three.

Next.js + UnfoldCMS: How It Works Today

Honest version: UnfoldCMS today is a full Laravel CMS. It does not yet ship a public headless API for blog posts and pages. To use it as a content backend for a Next.js site, you write a small Laravel route in your CMS that returns the data you want as JSON, then fetch it from Next.js.

This is more work than next-sanity or next-payload. It's also more flexible — you decide exactly which fields are public, no SDK lock-in, no rate limit gotchas. For a content site or marketing site, it's a one-hour setup.

1. Add a public route in your Laravel CMS

In routes/web.php or routes/api.php of your UnfoldCMS install:

Route::get('/public/posts/{slug}', function (string $slug) {
    $post = \App\Models\BlogPost::where('slug', $slug)
        ->where('is_published', true)
        ->firstOrFail();

    return response()->json([
        'title' => $post->title,
        'body' => $post->body_html,
        'posted_at' => $post->posted_at,
    ]);
});

Five lines. Pick whichever fields your Next.js site needs.

2. Fetch from a Server Component

// app/blog/[slug]/page.tsx
async function getPost(slug: string) {
  const res = await fetch(
    `${process.env.UNFOLD_API_URL}/public/posts/${slug}`,
    { next: { revalidate: 60 } }
  );
  return res.json();
}

export default async function BlogPost({ params }: { params: { slug: string } }) {
  const post = await getPost(params.slug);
  return (
    <article>
      <h1>{post.title}</h1>
      <div dangerouslySetInnerHTML={{ __html: post.body }} />
    </article>
  );
}

Standard Next.js fetch, with built-in time-based revalidation. No SDK, no auth dance, no rate limit handling.

What's coming

Headless mode is on the roadmap and will replace the manual route step above:

• Public, versioned REST + GraphQL endpoints for posts, pages, settings, and media
• Signed webhooks on content events (publish, update, delete) — wireable to revalidateTag in Next.js
• Draft preview tokens with a one-click "Preview in Next.js" button in the admin
• Official @unfoldcms/next SDK with typed responses and revalidation helpers

Until those ship, the manual-route pattern above is the supported way to use UnfoldCMS with Next.js.

Performance: Why Self-Hosted Plus CDN Often Beats Managed CMS

Most Next.js sites don't actually benefit from a managed CMS's CDN. Here's why.

Vercel (or Netlify, Cloudflare Pages) already caches your static and ISR pages globally. A user request to your /blog/[slug] page hits Vercel's edge — your CMS API is only called when the cache misses or revalidation fires. That happens once per content change, not once per visitor.

So the "global CDN" Sanity or Contentful charges for is duplicative for most use cases. You're paying for edge content delivery you already have. The CDN matters for media assets (images, video) — and even there, Cloudflare's free tier or Cloudflare Images at $5/month handles 99% of cases.

For UnfoldCMS specifically: your Next.js Vercel deploy caches everything. Your $5/month UnfoldCMS host serves the API maybe a few hundred times per day after revalidation. The architecture is fundamentally cheaper than paying $99–$300/month for a hosted CMS to serve content that ends up cached at the edge anyway.

This isn't theoretical — it's how the current site you're reading is built. Self-hosted CMS + Cloudflare in front + ISR. Hosting bill: under $20/month total.

Trust Block

Who this is for: Next.js developers shipping marketing sites, blogs, or content-driven SaaS who want a CMS that pairs cleanly with Next.js without per-seat fees, API quotas, or fighting their hosting bill every quarter.

What it replaces: Sanity ($99/project/month), Contentful ($300+/month), Strapi (Node deploy ops burden), or headless WordPress + WPGraphQL plugin chaos.

What it costs: $39 one-time (Core, 1 domain) up to $799 (Agency, unlimited domains). No per-seat fees, no API metering.

What happens after you buy:

1. Install UnfoldCMS on any PHP 8.3 host — under 5 minutes, no Docker required
2. Add a small Laravel route to expose content as JSON, fetch from Next.js Server Components
3. Use Next.js ISR or full SSG — UnfoldCMS handles the editorial workflow, Next.js handles rendering

FAQ

What's the best free CMS for Next.js? For pure OSS, Payload (MIT-licensed Node CMS) and Strapi (community edition) are the two strongest options. Both are self-hosted, both work cleanly with Next.js. Payload has the better developer experience; Strapi has a wider plugin ecosystem.

Which CMS works best with Next.js App Router and Server Components? Payload (Local API runs in-process) and Sanity (next-sanity package) have the smoothest official integrations today. UnfoldCMS works via a custom Laravel route + standard fetch() — slightly more setup, no SDK lock-in. Avoid CMSes that require client-side SDKs only — they break the Server Component model.

Is WordPress good for headless Next.js? It works, but the DX is rough. WPGraphQL plus Next.js gets you content, but you fight schema mismatches with custom field plugins, and the WordPress admin UI doesn't map cleanly to a structured content model. Use only if you have an existing WordPress team that won't migrate.

How do I do preview mode in Next.js with a headless CMS? Use Next.js Draft Mode (App Router) or Preview Mode (Pages Router). Your CMS issues a draft token; your Next.js route enables Draft Mode based on a cookie or query param; your fetch calls switch to draft endpoints. Sanity and Payload support this out of the box. UnfoldCMS does not ship draft preview tokens today — it's on the roadmap. For now you can wire your own toggle in a custom Laravel route.

What's the cheapest CMS for a Next.js site? A one-time UnfoldCMS license at $39 plus $5/month shared hosting is the cheapest production-grade option. Payload self-hosted is free if you operate the Node infrastructure yourself; Sanity's free tier works for hobby projects but caps at 3 users and 10k documents.

Can I migrate from Sanity or Contentful to UnfoldCMS for my Next.js site? Yes. Both Sanity and Contentful expose content export tools (sanity dataset export, Contentful CLI export). Map content types to UnfoldCMS post types, import via REST API, update Next.js fetch URLs. Half-day project for typical content sites; we offer a Migration Service starting at $149.

Does UnfoldCMS support GraphQL for Next.js? Not officially yet. Today you expose data via a small Laravel JSON route (REST). A first-class GraphQL endpoint is on the roadmap alongside the public REST API and SDK.

Will my Next.js site be slower with a self-hosted CMS than a managed one? For most sites, no. Vercel/Netlify cache your pages at the edge, so the CMS is only called on content changes (via ISR revalidation). The "global CDN" of managed CMSes is duplicative. Pair UnfoldCMS with Cloudflare in front for media assets — under $5/month total CDN bill.

Methodology

Pricing data is from each vendor's public pricing page as of April 2026. Stack and feature evaluations reference official Next.js documentation, each CMS's developer docs, and direct integration testing on production Next.js 15 projects. Quotes and community sentiment are sourced from r/nextjs, r/reactjs, and Hacker News public discussions. Performance claims about ISR + edge caching reflect Vercel's published architecture and our own production deployments.

Try UnfoldCMS for Your Next.js Project

If UnfoldCMS sounds like the right fit, the live demo takes about 90 seconds — browse the admin, create a post, see how the API responds. Pricing is one-time and all tiers include the full source. The Core tier at $39 lets you test the full product on a real Next.js project.

For more comparisons specific to your evaluation, see UnfoldCMS vs Sanity, vs Payload, vs Contentful, or vs WordPress. Each one digs into the trade-offs honestly — including where the competitor wins.

If a different CMS in this list fits your project better, that's a fine answer too. The point of this page is to give you the information to decide, not to pretend UnfoldCMS is the answer to every Next.js project.

Related: UnfoldCMS vs Sanity, migrate from Contentful, or browse all CMS comparison guides.