Sanity is a managed headless CMS with a React-based Studio that can be self-hosted or embedded in your Next.js app. The content is stored in Sanity's cloud infrastructure (in the region of your choice). The Vercel x Sanity starter includes: Sanity Studio embedded in the Next.js app (/studio route) Live preview with Sanity's @sanity/visual-editing GROQ queries for fetching content Incremental Static Regeneration configuration

Strapi is the most established open-source headless CMS — 64,000+ GitHub stars and 50,000+ developers. It generates REST and GraphQL APIs from a schema you define in the admin UI or code. The Strapi + Next.js starter provides: Strapi backend running as a separate service Generated REST or GraphQL API Next.js frontend fetching from the Strapi API Content types (articles, categories, authors) Authentication (users + permissions)

Payload Starter vs Sanity Starter vs Strapi 2026

Three CMS Philosophies, Three Starter Experiences

Choosing a headless CMS for your Next.js project is choosing a content philosophy:

Payload CMS — Code-first, self-hosted, Next.js-native. The CMS lives inside your Next.js app. No separate backend service.
Sanity — Cloud-first, collaboration-first. A managed SaaS CMS with real-time multiplayer editing and GROQ queries.
Strapi — Open-source, REST/GraphQL first. Self-hosted Node.js backend with a visual schema builder and 50,000+ developer adoption.

Each has official Next.js starters, documented deployment paths, and production usage across thousands of projects. The right choice depends on your team's priorities: developer control, content editor experience, or deployment simplicity.

TL;DR

Payload CMS starter — Best for developers. Runs inside Next.js with a Local API, full TypeScript, database flexibility. Open source. Figma acquired Payload in June 2025 — strategic validation, uncertain long-term implications.
Sanity starter — Best for teams with content editors. Real-time collaboration, GROQ queries, managed infrastructure, generous free tier. Vendor lock-in through GROQ and hosted Studio.
Strapi starter — Best for REST/GraphQL APIs and existing workflows. Open-source, mature ecosystem, free cloud tier, visual schema builder. Declining npm downloads in 2025 raise long-term questions.

Key Metrics

Metric	Payload CMS	Sanity	Strapi
License	MIT (open source)	Proprietary (SaaS)	MIT + commercial
Hosting	Self-hosted (or cloud)	Managed SaaS	Self-hosted or Strapi Cloud
Free tier	Full (self-hosted)	Yes (generous)	Yes (Strapi Cloud free)
GitHub stars	33,000+	N/A (SaaS)	64,000+
Next.js integration	Native (installed in app)	External (Studio separate)	External (separate service)
Database support	PostgreSQL, MongoDB, SQLite	Managed (Sanity's cloud)	Multiple
Query language	TypeScript API (Local API)	GROQ (proprietary)	REST + GraphQL
Real-time collab	No	Yes	No
Acquired by	Figma (June 2025)	Independent	N/A
npm trend (2025)	Rising	Stable	Declining

Payload CMS Starter

What It Is

Payload CMS 3.0 represents a significant architectural shift: instead of being a separate backend service, Payload installs directly into your Next.js app folder. The CMS and your application share the same Next.js process.

The official Payload website template (available on Vercel's template gallery) provides:

Full-featured admin panel (Payload's built-in admin UI)
Rich text blocks with custom components
Media management
Auth (built-in to Payload)
On-demand revalidation
Live preview in the admin

The Local API

Payload's most powerful feature for developers is the Local API:

import { getPayload } from 'payload'
import config from '@payload-config'

// In a React Server Component:
const payload = await getPayload({ config })
const posts = await payload.find({
  collection: 'posts',
  where: { _status: { equals: 'published' } },
  depth: 2
})

This runs directly in your Next.js Server Component — no HTTP request, no network latency, no API rate limits. The data is fetched from the database directly, with Payload's access control applied.

Pricing

Payload is free and open source (MIT). Hosting costs are your server costs — a Postgres database and a Node.js host. No per-user fees, no content limits, no API call limits.

A managed Payload Cloud offering exists for teams that want hosted infrastructure.

The Figma Acquisition

In June 2025, Figma acquired Payload CMS. This brought institutional resources to the project but also raised questions about long-term open-source commitment. So far, Payload has remained MIT-licensed with active development continuing under Figma's ownership. The npm download trend shows acceleration post-acquisition.

Sanity Starter

What It Is

Sanity is a managed headless CMS with a React-based Studio that can be self-hosted or embedded in your Next.js app. The content is stored in Sanity's cloud infrastructure (in the region of your choice).

The Vercel x Sanity starter includes:

Sanity Studio embedded in the Next.js app (/studio route)
Live preview with Sanity's @sanity/visual-editing
GROQ queries for fetching content
Incremental Static Regeneration configuration

GROQ: Sanity's Differentiator

GROQ (Graph-Relational Object Queries) is Sanity's proprietary query language. It is powerful and expressive for complex content relationships:

*[_type == "post" && publishedAt < now()] | order(publishedAt desc) {
  title,
  "author": author->{name, image},
  "categories": categories[]->{title},
  body,
  publishedAt
}

GROQ can filter, transform, and project data in a single query. The downside: it is proprietary. You learn GROQ for Sanity, and only for Sanity.

Real-Time Collaboration

Sanity's Studio supports multiplayer content editing — multiple editors can work on the same document simultaneously, with presence indicators and conflict resolution. This is Sanity's competitive advantage over every self-hosted CMS.

For marketing teams and content-heavy organizations, this feature alone justifies the Sanity choice.

Pricing

Sanity has a generous free tier:

Free: 3 users, 2 datasets, 20GB CDN bandwidth, 500k API requests/month
Growth ($15/user/month): More users, bandwidth, and requests
Custom: Enterprise pricing

For small teams and early-stage products, the free tier is usually sufficient. For larger teams, per-user pricing can add up.

Strapi Starter

What It Is

Strapi is the most established open-source headless CMS — 64,000+ GitHub stars and 50,000+ developers. It generates REST and GraphQL APIs from a schema you define in the admin UI or code.

The Strapi + Next.js starter provides:

Strapi backend running as a separate service
Generated REST or GraphQL API
Next.js frontend fetching from the Strapi API
Content types (articles, categories, authors)
Authentication (users + permissions)

Visual Schema Builder

Strapi's Content-Type Builder is a visual interface for defining your data models. Non-developers can define new content types without touching code. This is Strapi's strong suit for teams with mixed technical skills.

REST and GraphQL by Default

Strapi generates both REST and GraphQL APIs automatically from your schema. No additional configuration. This makes Strapi the easiest choice for teams integrating with existing REST consumers or GraphQL clients.

Pricing

Strapi is open source (MIT). Self-hosting is free. Strapi Cloud offers:

Free plan: Production-grade environment, no credit card
Pro plan ($29/month): Custom domain, more storage, priority support
Scale plan (custom pricing): Enterprise features

The free Strapi Cloud tier is a meaningful recent addition — teams can deploy Strapi without infrastructure management and without cost.

The Declining Trend

An honest note: Strapi's npm downloads declined notably in 2025 while Payload's rose. This may reflect a shift in the Next.js ecosystem toward Payload's native integration model. Strapi's active GitHub repo and large community still represent significant momentum, but the trend is worth monitoring.

CMS Starter Comparison: Feature by Feature

Feature	Payload	Sanity	Strapi
Installation	Inside Next.js	External (hosted or embedded)	External (separate service)
Admin UI	Built-in, customizable	Sanity Studio (React)	Strapi Admin (React)
Query method	Local API (TypeScript)	GROQ + CDN API	REST + GraphQL
Real-time collab	No	Yes	No
Content versioning	Draft/published	Draft/published	Draft/published
Custom components	Yes (block editor)	Yes (Portable Text)	Yes (custom fields)
Media management	Yes	Yes	Yes
Auth built-in	Yes	No (Sanity manages)	Yes (users + roles)
Database flexibility	PostgreSQL, MongoDB, SQLite	Managed (no choice)	Multiple
TypeScript	First-class	Good	Good
Vendor lock-in	Low (self-hosted, MIT)	High (GROQ, hosted)	Low (self-hosted, open source)
Content editors	Moderate	Excellent	Good
Developer experience	Excellent (for Next.js)	Good	Good
Pricing model	Free (self-hosted)	Per-user SaaS	Free + cloud tiers
i18n	Yes	Yes	Yes

Deployment Complexity

Payload: Deploy your Next.js app as usual (Vercel, Railway, etc.). You need a Postgres database (Neon, Supabase, or your own). The admin panel and API are part of your app — no separate service to deploy.

Sanity: Deploy the Next.js frontend as usual. The Sanity Studio can be embedded in your app or deployed separately. The content database is Sanity's — you pay for it but do not manage it.

Strapi: Deploy Strapi as a separate Node.js service (or use Strapi Cloud). Deploy your Next.js frontend separately. Manage two services, two deployment pipelines, two environments.

Payload wins on deployment simplicity for Next.js projects. Strapi requires the most infrastructure management.

Who Each CMS Starter Is For

Choose Payload if:

You are building a Next.js app and want the CMS inside your project, not as a separate service
You want full database control and no vendor lock-in
You are comfortable writing TypeScript queries (Local API) instead of GROQ or REST
Cost predictability matters — self-hosted Payload has no per-user or per-API-call fees
You want to leverage React Server Components to query CMS content directly

Choose Sanity if:

Your team includes non-technical content editors who need a polished editing experience
Real-time collaboration between editors is a requirement
You want managed infrastructure without database administration
You are comfortable with GROQ and the Sanity ecosystem
The generous free tier fits your initial usage

Choose Strapi if:

Your team wants REST or GraphQL APIs as the primary interface to content
Non-developers need to define content types using the visual builder without code
You want the largest open-source headless CMS community and ecosystem
Free cloud hosting (Strapi Cloud free tier) is important for getting started
You are integrating with systems that expect a standard REST API

The Verdict

For Next.js projects in 2026, Payload CMS is the most compelling technical choice. The Local API, native Next.js integration, and self-hosted freedom are strong advantages for developer-controlled projects.

Sanity wins when content editors matter. Real-time collaboration and the polished Studio experience are unchallenged in the headless CMS market.

Strapi is best for REST/GraphQL API-first projects where the visual schema builder adds team value and existing REST consumers need a straightforward integration.

Content Editor Experience Matters More Than You Think

Developers choosing between these three CMS starters typically evaluate the technical architecture — query language, hosting model, TypeScript support, self-hosting options. The dimension that is frequently underweighted is the content editor experience, particularly in B2B SaaS products where the person maintaining the marketing site, product blog, or help documentation is not the developer who chose the CMS.

Sanity's Studio is the most polished content editing environment of the three. The real-time collaborative editing, the preview panel showing content changes alongside the rendered output, and the structured document editor with custom block components provide an experience that non-technical editors can use productively with minimal training. If your marketing team, content manager, or non-technical co-founder will be creating and editing content in this CMS on a weekly basis, Sanity's editor advantage is real and substantial.

Payload's admin interface is clean and functional, but it is clearly designed with developers as the primary user. The field editor reflects the code-first schema definition — which means complex nested block structures that a developer defines naturally in TypeScript can feel unfamiliar to a non-technical editor who expects something closer to a word processor. Payload's live preview feature (introduced in version 3.0) closes some of this gap by letting editors see changes in the rendered page in real time.

Strapi's visual schema builder is genuinely useful for non-technical team members who need to define new content types without touching code. However, the content editing interface itself is functional rather than polished — editors can create and update content, but the experience does not match Sanity's quality.

For teams where developer control and cost matter more than editor polish, Payload or Strapi are the right choices. For teams where non-technical content creators are primary users of the CMS, Sanity's editing experience is worth the vendor dependency.

For the full picture of CMS integration within broader SaaS boilerplates, the Payload SaaS starter review covers the Payload stack in depth. The best SaaS boilerplates 2026 roundup covers boilerplates with CMS integration built in. And why most boilerplates choose Next.js explains the architectural choices that make Payload's Next.js-native integration so appealing in 2026.

Methodology

This comparison is based on publicly available information from each CMS's official documentation, GitHub repositories, pricing pages, and community resources as of March 2026. npm download trend data reflects publicly available npm statistics.

Looking for a complete SaaS boilerplate with CMS integration? StarterPick compares boilerplates with built-in CMS support alongside those that integrate with Sanity, Payload, and Strapi.

The SaaS Boilerplate Matrix (Free PDF)