Headless CMS in 2026 — Sanity / Contentful / Strapi 5 / Payload (Figma acquisition) / Directus / Keystatic / Storyblok Deep Dive

Prologue — "Where Should the Content Live?"

A marketing PM said this in 2026.

"We are rebuilding on Next.js. Who owns the content model? Marketers must be able to change text and images themselves, multilingual must work, we want to assemble pages with a builder, and ideally developers can still write in MDX."

That is the ordinary request in 2026. "Just install a CMS" is no longer the answer. You have to find your team's spot on a five-axis matrix: editor UX, data model, API shape, deployment model, price, and lock-in.

This piece lays the whole headless CMS market on one page as of May 2026, with the strengths, weaknesses, and the last twelve months of changes for each one. Strapi 5's Document Service (Sept 2024), the open-source community controversy around Payload's acquisition by Figma (Sept 2024), the current state of Hygraph (formerly GraphCMS) — let's stop postponing the decision and sort it out.

1. The 2026 Headless CMS Map — Four Tribes

First we cut the whole market into four tribes. A CMS can straddle two tribes, but we classify by primary operating model.

This taxonomy matters because editor UX, operational responsibility, and lock-in differ by tribe.

• SaaS: best editor UX, no ops, large lock-in (you can export data but the API, image transforms, and real-time go away).
• Open source self-host: small lock-in, large ops burden (DB, backups, scale). Easy to run as a container, but you own the marketer-friendly UX yourself.
• Git-based: almost no lock-in (your content is markdown in your repo), but marketers need a GitHub login.
• Visual: maximum marketer autonomy, but developers struggle to keep design-system consistency.

A summary on axes:

Now we go tribe by tribe.

2. Sanity — The Real-Time Standard

Sanity started in Norway in 2017, and in 2026 it is increasingly the favorite SaaS among developers.

Core traits

• Sanity Studio — an editor UI where the content model is defined in TypeScript code. The screen marketers use lives inside your repo as code.
• GROQ — not GraphQL but a custom query language. JSON-like syntax with deep joins and filtering.
• Portable Text — not plain markdown but a JSON rich text that lets you inject arbitrary blocks.
• Real-time — multiple editors on the same document look like Google Docs.
• Content Lake — hosted datastore with an asset CDN and image transforms built in.

// schemaTypes/post.ts — Sanity Studio schema
import { defineField, defineType } from 'sanity'

export const post = defineType({
  name: 'post',
  type: 'document',
  fields: [
    defineField({ name: 'title', type: 'string', validation: (r) => r.required() }),
    defineField({ name: 'slug', type: 'slug', options: { source: 'title' } }),
    defineField({ name: 'body', type: 'array', of: [{ type: 'block' }] }),
    defineField({
      name: 'author',
      type: 'reference',
      to: [{ type: 'author' }],
    }),
  ],
})

A GROQ query looks like this.

// Fetch a post list from Next.js
import { createClient } from '@sanity/client'

const client = createClient({
  projectId: 'abc',
  dataset: 'production',
  apiVersion: '2026-05-16',
  useCdn: true,
})

const posts = await client.fetch(`
  *[_type == "post" && defined(slug.current)]
  | order(publishedAt desc)[0...10]{
    title, "slug": slug.current, publishedAt,
    author->{name, avatar}
  }
`)

What changed in 2026

• AI Assist — LLM-driven translation, summarization, and alt-text generation added in 2024–2025 has stabilized.
• Sanity Connect — connectors that pull from external systems like Shopify or Stripe.
• Live Content API — subscribe to a GROQ query and get pushed updates when data changes. Useful for dashboards and live sites.

Strengths and weaknesses

Who should pick it

• Teams with a complex content model that changes often.
• Teams managing multilingual, multi-channel, multi-region content in one place.
• Magazines and media where many editors work simultaneously.

3. Contentful — The Enterprise Default

Contentful started in Berlin in 2013, and in 2026 it is still the default enterprise headless CMS. It almost always appears on RFPs from large companies.

Core traits

• Content Model — define fields in the web UI, type system (Symbol, Text, Reference, Asset, JSON).
• Compose — page-level editing UI (enterprise add-on).
• GraphQL / REST / CDN API — all supported, global CDN.
• App Framework — embed your own apps into the editor to extend workflow.
• Locales — first-class multilingual support.

// Contentful GraphQL query
const query = `
  query {
    postCollection(limit: 10, order: publishDate_DESC) {
      items {
        title
        slug
        publishDate
        author { name }
      }
    }
  }
`

const res = await fetch(
  `https://graphql.contentful.com/content/v1/spaces/${process.env.CONTENTFUL_SPACE_ID}/environments/master`,
  {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.CONTENTFUL_TOKEN}`,
    },
    body: JSON.stringify({ query }),
  },
)

Strengths and weaknesses

Who should pick it

• Enterprises and finance, media where compliance and SLAs are mandatory.
• Organizations with formalized content workflow (draft to review to publish).
• Operations with many locales and dedicated editors per locale.

4. Strapi 5 (Sept 2024) — Plugins v5 + Document Service

Strapi is a French-origin open-source headless CMS. Node/TS-based, MIT-licensed. Strapi 5 GA shipped in September 2024, and in 2026 the default entry point is v5.

Key changes in v5

• Document Service API — replaces v4's Entity Service. Drafts, publish, and locales unified into a consistent API.
• Plugins v5 — plugin marketplace cleaned up, TypeScript-first.
• Server-side React Admin — admin panel rewritten.
• Vite-based build — admin build time dropped sharply.

// Strapi 5 Document Service API example (inside a custom route)
const documents = await strapi.documents('api::article.article').findMany({
  filters: { publishedAt: { $notNull: true } },
  sort: { publishedAt: 'desc' },
  populate: ['author'],
  status: 'published',
  locale: 'en',
})

// Explicit handling of drafts vs published is the v5 distinction
const draft = await strapi.documents('api::article.article').findOne({
  documentId: 'abc123',
  status: 'draft',
})

Strengths and weaknesses

Who should pick it

• Teams that want to run on their own infra (Kubernetes, outside Vercel).
• Organizations that want data in their own DB (Postgres) with full backup and replication control.
• Teams willing to write plugins to extend workflow.

5. Payload (Acquired by Figma Sept 2024) — TS-First Controversy

Payload is a TypeScript-first headless CMS. It launched in 2021 and rapidly built a developer following. In September 2024, Figma acquired Payload, and the open-source community immediately raised concerns — "as Figma integrates Payload into its own products, won't the open-source identity blur?"

As of May 2026, observations: Payload retains the MIT license, and the core is actively developed in the open. But Payload Cloud (hosted) and Figma-side integrations are growing faster than before. Part of the community sees this as "gradual enclosure."

Core traits

• TypeScript-first — schema integrates with TS types, admin components are React/TS.
• Code-first config — content model defined in payload.config.ts.
• Local API — call functions that hit the DB directly from Next.js server components.
• Access Control — permissions defined as functions.
• Blocks — page-builder-like component composition.

// payload.config.ts
import { buildConfig } from 'payload'
import { mongooseAdapter } from '@payloadcms/db-mongodb'

export default buildConfig({
  collections: [
    {
      slug: 'posts',
      fields: [
        { name: 'title', type: 'text', required: true },
        { name: 'slug', type: 'text', required: true, unique: true },
        {
          name: 'content',
          type: 'richText',
        },
        {
          name: 'author',
          type: 'relationship',
          relationTo: 'users',
        },
      ],
      access: {
        read: () => true,
        create: ({ req }) => Boolean(req.user),
      },
    },
  ],
  db: mongooseAdapter({ url: process.env.MONGODB_URI! }),
})

// Query directly from a Next.js server component
import { getPayload } from 'payload'
import config from '@/payload.config'

export default async function PostPage({ params }: { params: { slug: string } }) {
  const payload = await getPayload({ config })
  const result = await payload.find({
    collection: 'posts',
    where: { slug: { equals: params.slug } },
    limit: 1,
  })
  const post = result.docs[0]
  return <article>{post.title}</article>
}

Implications of the Figma acquisition

• Upside — capital and headcount accelerate core development; potential integration with Figma's design system.
• Risk — hosted product gets features first while OSS lags; possible license change (history has examples at other companies).
• Today — MIT preserved, active core commits. But decision authority sits with the acquiring company, so evaluate lock-in risk yourself.

Who should pick it

• Teams where TS developers are the primary users.
• Workflows where the content model must be version-controlled as code.
• Teams that want deep Next.js / React integration (callable from server components).

6. Directus — Built Backwards, from DB to API

Directus's premise is unusual. Most CMS go "admin UI to DB"; Directus bolts onto an existing SQL DB and auto-generates the admin UI and REST/GraphQL API. Your existing data becomes a CMS.

Core traits

• DB-first — use Postgres, MySQL, SQLite, MSSQL as is.
• Auto API — REST and GraphQL generated from table definitions.
• No-code admin — what marketers use.
• Flows — automation with conditions, webhooks, scripts.
• Extensions — add hooks, endpoints, panels.

-- An existing articles table
CREATE TABLE articles (
  id SERIAL PRIMARY KEY,
  title TEXT NOT NULL,
  slug TEXT UNIQUE NOT NULL,
  content TEXT,
  published_at TIMESTAMPTZ
);

Connect this table to Directus and you immediately get an admin UI and APIs.

# Fetch via REST
curl "https://cms.example.com/items/articles?fields=*,author.*&filter[status][_eq]=published"

# Fetch via GraphQL
curl -X POST https://cms.example.com/graphql \
  -H "Content-Type: application/json" \
  -d '{"query":"{ articles(filter:{status:{_eq:\"published\"}}){ title slug }}"}'

Strengths and weaknesses

Who should pick it

• Teams that want to expose existing SQL data to marketers.
• Organizations that want to consolidate site + internal ops tools into one admin.
• When you want to merge data, CMS, and admin tooling into a single thing.

7. Cosmic / Builder.io — Visual + Headless

Both center on "marketers build the page themselves."

Cosmic

• Founded in 2014, SaaS headless CMS.
• A more SaaS-standard content object model (objects, metafields).
• Plenty of Next.js / React starters; great for small teams getting up quickly.
• Recently strengthened AI-driven content generation and translation.

Builder.io

• Visual page builder + headless API.
• Drag-and-drop editor where marketers compose pages from React components.
• Visual Copilot — turn Figma designs into code.
• A/B tests and personalization built in.
• Mitosis converts components to multiple frameworks.

// Render a Builder.io page in Next.js
import { builder, BuilderComponent } from '@builder.io/react'

builder.init(process.env.NEXT_PUBLIC_BUILDER_KEY!)

export default async function Page({ params }: { params: { slug: string[] } }) {
  const content = await builder
    .get('page', { url: '/' + params.slug.join('/') })
    .toPromise()

  return <BuilderComponent model="page" content={content} />
}

Who should pick them (both)

• Marketing or content teams want to build pages without engineers.
• e-commerce and SaaS with frequent landing pages and campaigns.
• Operations that need page-level A/B tests and personalization.

But design-system consistency is easy to lose. Pre-narrowing the catalog of usable components is the key.

8. Keystatic (Thinkmill) — Git-Based TS-First

Keystatic is built by Australia's Thinkmill, and Mark Pinches is one of the core maintainers. It launched in 2023, and in 2026 it has settled in as the TS-first flagship of Git-based CMS.

Core traits

• Content lives as markdown/YAML/JSON in a Git repo — no DB.
• Schema in TypeScript code — type-safe.
• Local admin UI — edit markdown visually on localhost.
• GitHub app mode — marketers sign in via GitHub OAuth, changes go through commits/PRs.
• Integrates with Next.js, Astro, Remix.

// keystatic.config.ts
import { config, fields, collection } from '@keystatic/core'

export default config({
  storage: { kind: 'github', repo: 'me/blog' },
  collections: {
    posts: collection({
      label: 'Posts',
      slugField: 'title',
      path: 'content/posts/*',
      format: { contentField: 'content' },
      schema: {
        title: fields.slug({ name: { label: 'Title' } }),
        publishedAt: fields.date({ label: 'Published' }),
        content: fields.markdoc({ label: 'Content' }),
      },
    }),
  },
})

Strengths and weaknesses

Who should pick it

• Blogs, doc sites, small marketing sites.
• Developer-led teams that want content managed in PR-based workflow.
• Organizations where "no content in external SaaS" is a hard requirement.

9. Storyblok — The Visual Editor Heavyweight

Storyblok is an Austrian SaaS headless CMS launched in 2017. Its visual editor is the biggest differentiator.

Core traits

• Visual Editor — click directly on a site preview to edit.
• Bloks — a page is a composition of blocks; a block is a component.
• CDN API — global cache.
• Multilingual — field-level or folder-level translation.
• Pipelines — workflow management.

// Fetch a Storyblok page from Next.js
import { storyblokInit, apiPlugin, getStoryblokApi } from '@storyblok/react'

storyblokInit({ accessToken: process.env.STORYBLOK_TOKEN, use: [apiPlugin] })

export default async function Page({ params }: { params: { slug: string[] } }) {
  const slug = params.slug?.join('/') || 'home'
  const sb = getStoryblokApi()
  const { data } = await sb.get(`cdn/stories/${slug}`, { version: 'published' })
  return <StoryblokComponent blok={data.story.content} />
}

Strengths and weaknesses

Who should pick it

• When marketing wants to build pages themselves while engineers keep component control.
• Brands running multilingual sites with frequent global campaigns.
• Marketing sites for e-commerce and B2B SaaS.

10. Hygraph (formerly GraphCMS) — GraphQL First

GraphCMS rebranded as Hygraph in 2022. The name changed but the identity — a GraphQL-first headless CMS — did not.

Core traits

• GraphQL-native — GraphQL is the primary API, not REST.
• Content Federation — combine external GraphQL sources.
• First-class i18n — Localizations.
• Stages — DRAFT, PUBLISHED, etc.
• Asset Pipeline — image transforms and optimization built in.

# Hygraph GraphQL query
query Posts {
  posts(orderBy: publishedAt_DESC, first: 10, locales: [en, ko]) {
    id
    title
    slug
    publishedAt
    author {
      name
    }
  }
}

Who should pick it

• Existing infra already centered on GraphQL.
• Teams wanting to federate multiple data sources via GraphQL.
• Multilingual as a core dimension of the content model.

11. Prismic / Hashnode / Outstatic — Other SaaS and Git

Prismic

• 2013 French origin, an established SaaS CMS.
• Slices — reusable component fragments that marketers drop onto pages.
• Pricing reasonable for small teams.
• Strengths: stability, multilingual. Weakness: innovation pace slower than Sanity or Storyblok.

Hashnode

• SaaS specialized for developer blogs and newsletters.
• Custom CDN, SEO, newsletter delivery built in.
• Generous free tier, custom domain free.
• Headless API also available — use Hashnode as a content backend behind your own site.
• Who: individual developers and technical bloggers.

Outstatic

• A Next.js-friendly Git-based CMS.
• Same shape as Keystatic with Next.js integration first.
• Admin via GitHub OAuth, markdown commits.
• Who: solo developers spinning up small Next.js sites quickly.

12. Dato CMS / ButterCMS / KeystoneJS — Other Headless Options

Dato CMS

• Italian SaaS headless CMS.
• Modular Content — block-based rich text.
• Image pipeline — imgix integration.
• Strengths: rich field types and image handling. Weakness: price ramps fast.

ButterCMS

• API-first SaaS CMS, friendly to small teams.
• Clear, simple pricing.
• Multi-site support is a strength.
• Who: small companies wanting a blog and marketing pages quickly.

KeystoneJS

• TypeScript-first OSS headless (also built by Thinkmill — separate project from Keystatic).
• Prisma-based data model, auto-generated GraphQL API.
• Includes an admin UI.
• Who: teams that want a strong data model on self-host.

13. Ghost / WordPress Headless / Webflow / Notion — Non-Traditional CMS

These four are not "born headless" but get used as headless.

Ghost

• Node-based blog and newsletter platform.
• Among the cleanest native editor UX.
• Content API lets you use it as headless.
• Who: writers, newsletter operators, solo media.

WordPress headless

• WordPress still powers a huge chunk of the internet in 2026.
• WP REST API or WPGraphQL for headless mode.
• Strengths: vast plugin ecosystem, marketer familiarity. Weaknesses: WP operations burden, security.
• Who: organizations with deep WP content that want to move only the frontend to Next.js.

Webflow

• A site builder, but CMS Collections are exposed via API.
• Designers and marketers run design and content in parallel.
• Headless mode: Webflow as content backend, Next.js on the frontend.
• Who: designer-led marketing sites.

Notion as CMS

• Notion API plus build-time fetch to drive a site.
• Lowest-friction editor (every company already uses Notion).
• Weaknesses: API rate limits, image URL expiry, content modeling constraints.
• Who: early-stage startup marketing sites and doc sites.

14. decap CMS (formerly Netlify CMS) / Statamic — Git-Based and Flat-File

decap CMS (formerly Netlify CMS)

• Originally Netlify CMS, renamed to decap CMS in 2023 and moved to community stewardship.
• Git-based, markdown commits, OAuth with GitHub/GitLab/Bitbucket.
• Often paired with static site generators (Hugo, Jekyll, Astro, Next.js).
• Strengths: free, zero lock-in. Weakness: community-driven, uneven release cadence.

Statamic

• Laravel-based flat-file CMS (no DB needed).
• Content stored as YAML/markdown on the file system.
• Includes its own admin UI.
• Headless mode (GraphQL/REST API) available too.
• Who: Laravel-familiar teams that want to keep content file-based.

15. Korea — Markdown CMS Trend and Kakao Contents

Patterns of headless CMS use in Korea in 2026.

Rise of markdown / Git-based

• More developers move from hosted blogs (velog, tistory) to self-hosted Next.js with Contentlayer / Keystatic / Outstatic.
• As 2024–2026 hiring increasingly weighs "your own technical blog," demand grew for markdown CMS with no lock-in.

Kakao Contents / Brunch / Naver

• Kakao Brunch Story is a writer-application SaaS with almost no API exposure. Hard to use as headless.
• Naver blogs and Tistory expose only RSS externally.
• Korean media companies (JoongAng, Hankyung, etc.) tend to use proprietary in-house CMS (custom builds plus WordPress / Drupal) and are migrating to headless gradually.

SaaS usage

• Korean enterprises have increasingly adopted Contentful, Sanity, and Storyblok. Especially e-commerce and game companies that need global multilingual sites (EN/KO/JA/ZH).
• Large players like LINE, Kakao, Coupang maintain their own CMS and tool chains.

Korean search and SEO considerations

• Korean SEO is still dominated by Naver, and Naver indexing leans heavily on sitemaps and RSS. The more headless the site, the more important it is to expose static HTML via SSG/ISR.

16. Japan — microCMS, Newt, Storyblok Japan

Japan is a market where local SaaS CMS are strong.

microCMS

• A Japan-built SaaS headless CMS, launched in 2019.
• Japanese UI and Japanese docs complete; one of the most-used headless CMS among Japanese companies.
• Content API, management API, and image API separated.
• Pricing friendly to Japanese companies, JPY billing.
• Who: sites focused on the Japanese market (EC, media, corporate sites).

// microCMS client
import { createClient } from 'microcms-js-sdk'

const client = createClient({
  serviceDomain: 'example',
  apiKey: process.env.MICROCMS_API_KEY!,
})

const data = await client.get({
  endpoint: 'posts',
  queries: { limit: 10, orders: '-publishedAt' },
})

Newt

• Japanese SaaS headless CMS launched in 2021, competes with microCMS.
• Japanese-first UX, local billing.
• Both GraphQL and CDN API.
• Who: same persona as microCMS, preferring more modern UX.

Storyblok in Japan

• Storyblok entered Japan in earnest in 2023–2024.
• Japanese UI and Japanese billing.
• Some large Japanese enterprises pick Storyblok over microCMS for global sites.

Contentful and Sanity usage

• Some large Japanese enterprises use Contentful, especially finance and automotive needing global compliance.
• Sanity's Japanese share is small but rising as an option in design and media startups.

17. Who Should Pick What — Decision Guide

Signals you picked wrong

• Marketers ask developers for every change — the CMS's editor UX is wrong.
• You cannot switch CMS because export feels scary — SaaS lock-in is too heavy.
• Build times explode with content volume — consider moving SSG-only to ISR/SSR, or lean more on a SaaS CDN.
• i18n keeps eating time — likely you picked a CMS where i18n is not first-class.
• You handle image transforms yourself — move to a CMS with CDN built in, or add Cloudinary / imgix.

Estimating migration costs

• SaaS to SaaS: data export then import mapping plus image re-upload. 1–2 weeks per 1000 entries.
• SaaS to self-host: the above plus infra setup. 2–4 weeks.
• WordPress to headless: content model redesign plus routing redesign. 2–6 weeks (blog) / 2–6 months (large sites).
• Git to SaaS: markdown to CMS field mapping script. 1–2 weeks.

Closing — Content Is an Asset

Picking a CMS is deciding where to keep your content asset. Tools can be swapped every five years, but the content you build up is your company's asset.

A one-line summary as of May 2026.

• Freedom and control: Strapi 5, Payload, Directus, Keystatic.
• Marketer UX and multilingual: Sanity, Contentful, Storyblok.
• Small site, no lock-in: Keystatic, Outstatic, Hashnode, decap.
• Visual page builder: Builder.io, Storyblok, Webflow.
• Japan: microCMS, Newt.

Two rules only. First, pick a CMS that guarantees a data export. Second, use the UI marketers will use every day, yourself, at least once. The rest is catalog detail.

References

• Sanity — https://www.sanity.io/
• Sanity GROQ docs — https://www.sanity.io/docs/groq
• Contentful — https://www.contentful.com/
• Strapi 5 release notes — https://strapi.io/blog/strapi-5
• Strapi Document Service API — https://docs.strapi.io/dev-docs/api/document-service
• Payload CMS — https://payloadcms.com/
• Payload joins Figma (2024-09) — https://payloadcms.com/blog/payload-joins-figma
• Directus — https://directus.io/
• Cosmic CMS — https://www.cosmicjs.com/
• Builder.io — https://www.builder.io/
• Keystatic — https://keystatic.com/
• Storyblok — https://www.storyblok.com/
• Hygraph (formerly GraphCMS) — https://hygraph.com/
• Prismic — https://prismic.io/
• Hashnode — https://hashnode.com/
• Outstatic — https://outstatic.com/
• Dato CMS — https://www.datocms.com/
• ButterCMS — https://buttercms.com/
• KeystoneJS — https://keystonejs.com/
• Ghost — https://ghost.org/
• WPGraphQL — https://www.wpgraphql.com/
• Webflow — https://webflow.com/cms
• Notion API — https://developers.notion.com/
• decap CMS — https://decapcms.org/
• Statamic — https://statamic.com/
• microCMS — https://microcms.io/
• Newt — https://www.newt.so/