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, includes themed frontend, Laravel-backed REST/GraphQL API). 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. See also: CMS for SaaS marketing sites.

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, UnfoldCMS) 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 + REST API + GraphQL. Self-hosted on any PHP 8.3 host (including shared hosting). The admin is built on shadcn/ui — 50 components, 183 admin pages, Tailwind v4, three switchable themes.

Next.js DX: Standard fetch() to REST endpoints from Server Components. ISR via webhook → revalidateTag() is a 12-line API route. Preview Mode wires up via JWT draft tokens. Image URLs are predictable; pair with Cloudflare Images for free CDN delivery.

Where it wins for Next.js: One-time pricing, no API metering means preview deploys don't burn budget. Includes a themed frontend if you want to ship a marketing site without building one in Next.js. Built-in SEO records, redirects, comments, and forms — features other CMSes outsource to plugins.

Where it loses: No real-time multi-cursor editing (Sanity wins there). No hosted CDN out of the box (you set up 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 want a CMS that ships a themed frontend so you can launch faster (or a headless API if you want pure Next.js)
• 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 Actually Works

Here's the integration in practice — the typical 30 minutes from npx create-next-app to live content on a Next.js page.

1. Fetch from a Server Component

// app/blog/[slug]/page.tsx
async function getPost(slug: string) {
  const res = await fetch(
    `${process.env.UNFOLD_API_URL}/api/blog/posts/${slug}`,
    { next: { tags: [`post:${slug}`] } }
  );
  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>
  );
}

That's it for the read path. No SDK, no auth dance, no rate limit handling.

2. ISR via webhook → revalidateTag

UnfoldCMS fires a webhook when posts are updated. Wire it to a Next.js route handler that revalidates the right tag:

// app/api/revalidate/route.ts
import { revalidateTag } from 'next/cache';
import { NextResponse } from 'next/server';

export async function POST(req: Request) {
  const secret = req.headers.get('x-unfold-webhook-secret');
  if (secret !== process.env.UNFOLD_WEBHOOK_SECRET) {
    return NextResponse.json({ error: 'unauthorized' }, { status: 401 });
  }

  const { slug } = await req.json();
  revalidateTag(`post:${slug}`);
  return NextResponse.json({ revalidated: true });
}

12 lines, no plugin needed. Set the webhook URL in UnfoldCMS admin → Settings → Webhooks.

3. Draft Mode for editors

Issue draft tokens from UnfoldCMS, set Next.js Draft Mode when the cookie is present, and fetch with ?preview=1:

// app/blog/[slug]/page.tsx
import { draftMode } from 'next/headers';

async function getPost(slug: string) {
  const isDraft = (await draftMode()).isEnabled;
  const url = `${process.env.UNFOLD_API_URL}/api/blog/posts/${slug}${isDraft ? '?preview=1' : ''}`;
  return fetch(url, { next: { tags: [`post:${slug}`] } }).then(r => r.json());
}

Editors click "Preview" in the UnfoldCMS admin, get redirected to your Next.js site with the draft cookie set, see the unpublished content, and can publish from there.

That's the entire Next.js + UnfoldCMS integration. Three files, no plugins, no monthly metering.

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.

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), Sanity (next-sanity package), and UnfoldCMS (standard fetch with ISR tags) all work cleanly. 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, Payload, and UnfoldCMS all support this; Storyblok and Contentful require slightly more manual wiring.

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? Yes. UnfoldCMS exposes both REST and GraphQL endpoints. Use GraphQL if your team prefers it; REST is recommended for Server Components since it's simpler to cache with Next.js's built-in fetch() cache integration.

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. If your stack is Astro instead, see the Best CMS for Astro breakdown. Each one digs into the trade-offs honestly — including where the competitor wins. See also: Best CMS for SvelteKit.

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.