Skip to content
Published on

Open Source Headless CMS 2026 Deep Dive - Strapi 5 / Directus 11 / Payload 3 / KeystoneJS / Sanity / Storyblok / TinaCMS / Decap CMS

🇰🇷KO🇺🇸EN🇯🇵JA
Split View필사 모드
Authors

Prologue - "CMS is no longer a single category"

In the early 2010s, the word "CMS" effectively meant one thing: WordPress. In 2026, CMS has split into at least five distinct categories.

  1. Traditional / Monolithic CMS - content plus presentation in one bundle. WordPress, Drupal, Joomla.
  2. Headless CMS - content served only as an API; the frontend is free. Strapi, Directus, Contentful.
  3. Hybrid / Visual CMS - visual editor plus headless API. Storyblok, Builder.io, Plasmic.
  4. git-backed CMS - content stored as markdown files committed to a repository. TinaCMS, Decap CMS, Outstatic.
  5. Markdown plus code-based CMS - workflow indistinguishable from code. Contentlayer, Velite, Astro Content Collections, Nuxt Content.

This post sorts the 12 main open-source headless CMS candidates as of May 2026, brings in the managed (SaaS) side - Sanity, Contentful, Hygraph, Storyblok, DatoCMS, ButterCMS, microCMS, Newt - as a comparison axis, and finally presents a decision matrix across four domains: marketing sites, docs, e-commerce, and mobile-app backends.

The headline conclusion - 2026 closes the era of "one CMS for everything." The right answer branches five ways depending on team size, data-model complexity, number of content editors, and whether you must self-host.

1. Headless vs Traditional CMS - What Actually Differs

The essential difference is simple.

AxisTraditional CMS (WordPress, Drupal)Headless CMS (Strapi, Sanity)
Content + presentationHandled togetherDecoupled. CMS is API only
Frontend freedomLocked to the theme systemAny framework
Multi-channelWeb by default, mobile is separateOne dataset feeds web, app, signage
SEOServer rendering by defaultYou wire up SSG/SSR
Learning curveFriendly to non-developersDeveloper-friendly
PerformanceHeavy once plugins accumulateLight to start, API-driven

The 2026 trend reads clearly.

  • WordPress still powers roughly 43% of the public web, per W3Techs CMS share data, basically unchanged.
  • But more than 70% of newly started marketing or product sites pick headless or git-backed.
  • The headless market itself is about 3x its 2022 size and still growing double-digit in 2026.

The point is not "WordPress is dead" but the default for new projects has shifted. And even WordPress is increasingly run as partly headless via WP-API plus Faust.js plus ACF.

2. Strapi 5 - The De Facto Standard for Node.js Headless

Strapi is the de facto standard open-source headless CMS in the Node.js world. More than 65k GitHub stars, more than 100 million cumulative downloads. Strapi 5, released in late 2024, made a paradigm shift to a document-based content model.

Core concepts

  • Content-Type Builder - define data models in the admin UI; migrations are generated automatically.
  • Document model (v5) - each content is a Document, and the Document contains multiple language/version Locales.
  • Draft & Publish - separate drafts from published, supports editorial workflow.
  • Plugins - auth, i18n, media library, GraphQL, and more extend via the plugin system.

Strengths

  • Self-hosting is free (MIT-licensed Community Edition).
  • REST and GraphQL out of the box.
  • TypeScript-first - v5 sharply improved type safety.
  • Rich plugin marketplace.
  • Strong i18n including Korean and Japanese.

Weaknesses

  • Self-hosting carries operational overhead - you manage the database, Redis, and media storage.
  • The admin UI slows down at very large content sizes (hundreds of thousands of items).
  • Some Enterprise features (SSO, fine-grained RBAC) are paid.

Strapi Cloud

Launched in 2023. A paid SaaS for teams that prefer not to run infrastructure. The fundamental difference from Contentful or Sanity is that the self-host option always stays alongside.

When to pick it

  • Teams that prefer the Node.js / TypeScript stack.
  • When you want self-hosting and a real admin UI.
  • Mid-sized marketing sites that mix multilingual content and media.

3. Directus 11 - "Instant API on Any SQL Database"

Directus starts from a different premise than most headless CMS products. It does not own a content database. It places an admin UI and an auto-generated REST/GraphQL API on top of an existing PostgreSQL, MySQL, or SQLite database.

Core concepts

  • Instant API - reads your DB schema and auto-generates REST plus GraphQL.
  • Schema-on-DB - collections created in the admin become real DB tables.
  • Flows - no-code automations. Trigger Slack, webhooks, or email on data change.
  • Insights - build dashboards inside the admin.
  • Files - integrates with S3, GCS, Cloudflare R2, and other storage backends.

Strengths

  • Data sovereignty - the database stays on your infrastructure.
  • Reuse legacy DBs - drop an admin UI onto an existing ERP or internal-system database.
  • BSL was simplified to MIT in 2024.
  • Free self-hosting with no user limit.

Weaknesses

  • Slightly off-genre inside the "headless CMS" category. Content workflow (Draft/Publish, review) is simpler than Strapi.
  • The media library exists by default but is not a full DAM.

Directus Cloud

A managed option exists. Free self-host and Cloud are both official products.

When to pick it

  • Organisations where PostgreSQL/MySQL is the core infrastructure.
  • Teams that want both an internal back-office and an external API from the same system.
  • Environments with compliance demands that the data must remain on owned infrastructure.

4. Payload 3 - Next.js-Native Full-Stack CMS

Payload represents a new generation of TypeScript full-stack headless CMS. Payload 3, released in November 2024, made a decisive move - it runs directly inside the Next.js App Router. No separate server process; the admin UI and API live in the same codebase as the Next.js app.

Core concepts

  • Code-first schema - content models are defined in TypeScript. There is no "define-in-UI then export" path.
  • Local API - access data via function calls without going through the DB. Extremely fast in SSR/SSG.
  • Access Control - functional permission policies, with row- and field-level control.
  • Lexical Rich Text - uses Meta's Lexical editor.
  • Drafts and Versions - versioning is on by default for every collection.

Strengths

  • MIT-licensed with no user limit and free self-hosting.
  • Same project as Next.js - no extra deployment pipeline.
  • TypeScript types are generated from the content model.
  • Supports MongoDB, PostgreSQL, and SQLite via the Adapter pattern.

Weaknesses

  • Code-first means non-developers cannot change the content model.
  • The community is still smaller than Strapi or Directus, though growing fast.
  • For non-Next.js frontends (mobile apps), the headline benefit shrinks.

Payload Cloud

A managed hosting option exists, with Vercel-friendly deployment as the default.

When to pick it

  • A Next.js full-stack team that wants everything in one project.
  • Teams who want TypeScript type safety to extend into content.
  • Projects with deep admin customization (Payload makes admin extension via React components intuitive).

5. KeystoneJS 6 - GraphQL-First, Thinkmill's Pick

KeystoneJS is a GraphQL-first headless CMS led by Australia-based Thinkmill. KeystoneJS 6 reached stable release in 2022 and remains on a steady maintenance trajectory in 2026 with incremental features.

Core concepts

  • Code-first schema - data models in TypeScript.
  • Prisma ORM-based - Prisma handles DB connectivity and migrations.
  • Auto-generated GraphQL - CRUD queries and mutations generated from models.
  • Admin UI - React-based with strong field customisation.

Strengths

  • GraphQL is a first-class citizen - REST needs separate wiring.
  • Prisma-based migration workflow is solid.
  • TypeScript type safety throughout.

Weaknesses

  • Smaller community than Strapi or Directus.
  • No official Cloud beyond self-hosting (Thinkmill's business model leans on consulting more than product Cloud).
  • Less attractive to teams that do not use GraphQL.

When to pick it

  • Product teams that use GraphQL heavily.
  • Teams wanting Prisma-based full-stack consistency.
  • Stability and simplicity over Strapi's plugin breadth.

6. Sanity - GROQ and Real-Time Collaboration, the Managed Champion

Sanity is a managed (SaaS) headless CMS run by a Norway-based company. The content studio itself is open source (MIT), but datasets and CDN live in Sanity Cloud.

Core concepts

  • GROQ (Graph-Relational Object Queries) - Sanity's own query language. A graph-style traversal syntax, distinct from GraphQL or SQL.
  • Real-time Collaboration - editing syncs in real time, comparable to Google Docs.
  • Portable Text - JSON-based rich text format. The best fit for headless.
  • Studio Customization - React-based studio is fully customisable.

Strengths

  • Smoothest real-time collaboration in the category.
  • Flexible content modelling (GROQ traverses arbitrarily).
  • Generous free tier (up to 3 users, 10k documents).
  • Image pipeline (auto-transform, CDN) is built in.

Weaknesses

  • Content data lives on Sanity's infrastructure - no self-host option.
  • GROQ has a learning curve (different from GraphQL).
  • Price ramps quickly with many users or documents.

When to pick it

  • Many content editors, where real-time collaboration is central.
  • Teams without self-hosting operations bandwidth.
  • Products whose content model is complex and changes often.

7. Storyblok - The Visual Editor Powerhouse

Storyblok is an Austria-based managed headless CMS. Its differentiator distils to one thing - the best visual editor.

Core concepts

  • Visual Editor - preview and edit the actual frontend site inside the admin.
  • Blocks - reusable content blocks (Hero, Feature, CTA, and so on).
  • Stories - page units, assembled from block trees.
  • Field Plugins - extend admin fields with custom React components.

Strengths

  • Marketers and editors compose pages directly.
  • Solid multilingual support (Spaces-level separation).
  • More than 100 integrations across e-commerce, analytics, and automation.

Weaknesses

  • Managed only - no self-host option.
  • Pricing scales fast by users and spaces.
  • Tightly coupled to the Visual Editor - the frontend must follow that structure.

When to pick it

  • Marketing sites as the main workload.
  • Environments where non-developers must adjust page layouts directly.
  • The most mature option in the Builder.io / Plasmic-style visual page-builder category.

8. TinaCMS - git-backed, Markdown-Centric

TinaCMS uses git as its backend. Content is stored not in a database but as markdown / MDX files committed to a repository.

Core concepts

  • git-backed - storage is commits to the repository. Content history equals git history.
  • Visual Editing - edit Next.js, Hugo, or Astro frontends from the admin.
  • TinaCMS Cloud - a managed option that orchestrates git branch workflows.

Strengths

  • Content lives inside the developer workflow - PRs and review feel natural.
  • Strong fit with static site generators (Hugo, Astro, Next.js).
  • No vendor lock-in for content.

Weaknesses

  • Editors need to grasp git (Cloud hides much of it, but not all).
  • Build times bottleneck at very large content sizes (tens of thousands of items).
  • The permission model is tightly bound to git permissions.

When to pick it

  • Developer-centric documentation sites (tech blogs, product docs).
  • Environments with low content change volume where history matters.
  • Markdown / MDX-first workflows.

9. Decap CMS - The Successor to Netlify CMS

Decap CMS is the 2022 fork-continuation of Netlify CMS. Same category as TinaCMS (git-backed) but a different origin - the original git-backed CMS from the Jamstack era.

Core concepts

  • git-backed - works on top of GitHub, GitLab, or Bitbucket.
  • Single HTML + JS admin - the admin lives at /admin on your static site.
  • Open Authoring - external contributors fork and PR content.

Strengths

  • Truly lightweight (admin is a single static asset).
  • Pairs naturally with Jamstack sites (Hugo, Eleventy, Jekyll).
  • Free in cost (static hosting is near-zero).

Weaknesses

  • Community is smaller than the Netlify CMS heyday.
  • Feature development has somewhat stalled.
  • Not a fit for large content volumes or complex workflows.

When to pick it

  • Small static sites, personal blogs, open-source project docs.
  • Open-source sites that accept external contributors.
  • When the absolute lightest CMS is required.

10. Webiny / Apostrophe / Plone / Drupal - Other Candidates

Webiny

  • Serverless (AWS Lambda, DynamoDB, S3, CloudFront) open-source headless.
  • Strong multi-tenancy. Used by large SaaS deployments.
  • AWS bill scales with usage.

Apostrophe

  • Node.js-based, with strong page-edit UX.
  • "In-context editing" - edit pages while viewing them.
  • Marketing and brand sites are the main target.

Plone CMS

  • A long-running Python (Zope) enterprise CMS.
  • Strong security, permissions, and multilingual model.
  • Still used by governments, universities, and non-profits.

Drupal 10/11

  • PHP-based. Drupal 11 released in 2025.
  • Strong at complex content models, multilingual, and permissions.
  • Operates as semi-headless via the JSON:API or GraphQL modules.
  • Sits on the boundary between traditional CMS and headless.

11. The WordPress Headless Camp - WP-API plus Faust.js plus ACF

WordPress itself is a traditional CMS, but in 2026 the headless usage pattern has stabilised.

Core tooling

  • WP REST API - REST endpoints built into WordPress core.
  • WPGraphQL - community plugin providing a GraphQL endpoint.
  • ACF (Advanced Custom Fields) - defines custom fields, central even in headless.
  • Faust.js - the Next.js framework from WP Engine, with WordPress as backend for SSR/SSG.

Strengths

  • Reuse existing WordPress content and plugins.
  • Editors keep the familiar WordPress admin.
  • Free, with a vast hosting ecosystem.

Weaknesses

  • WordPress core remains heavyweight.
  • Plugin compatibility (many plugins do not function in a headless context).
  • PHP operational burden persists.

When to pick it

  • Media or publishing organisations with huge existing WordPress content.
  • When editors refuse to learn anything other than WordPress.
  • Gradual migration strategies.

12. The Managed Headless Market - Contentful / Hygraph / DatoCMS / ButterCMS / Cosmic

Managed (SaaS) headless CMS plays a different game from open source. Their core value is not having to buy infrastructure operations.

ProductTraitBest-fit team
ContentfulThe de facto leader in managed headless. Enterprise pricing.Large enterprise, global marketing sites
Hygraph (formerly GraphCMS)GraphQL-first. Content Federation.GraphQL-first teams
DatoCMSStrong image and media pipeline.Design-heavy sites
ButterCMSThe simplest SaaS headless. Fast to start.Small blogs and marketing sites
CosmicMulti-tenant friendly. Content API plus CLI.Quick prototypes

Newer / mid-tier categories

  • Caisy - German newcomer with a multi-project console.
  • Prepr CMS - personalisation and A/B testing built in.
  • Magnolia - enterprise-only. Hybrid headless + traditional.
  • Crystallize - e-commerce-friendly headless.

Builder.io / Plasmic - Visual Page Builders

  • Builder.io - visual editor, headless API, A/B testing, and AI page generation.
  • Plasmic - close to a Figma-to-code experience. Designer-friendly.

These two stand out in the hybrid category of "visual page builder plus headless CMS" - competing directly with Storyblok.

13. Japanese Headless CMS - microCMS / Newt / a-blog cms

Japan has a robust domestic headless CMS lineup that is also worth knowing for non-Japanese readers.

microCMS

  • The de facto leader in Japanese headless CMS.
  • Japanese UI, Japan-region data centres, friendly to Japanese-company EC contracts.
  • Clear pricing with a generous free tier.
  • Used by major Japanese media and EC sites.

Newt

  • A newer-generation Japanese headless CMS. More full-stack-friendly than microCMS.
  • Sanity-style content modelling plus a GROQ-like query language.
  • Growing quickly inside Japanese startups.

a-blog cms

  • A long-standing traditional CMS from Japan's Appleple. PHP-based.
  • High share among Japanese corporate sites.
  • Supports a headless mode, but the traditional mode dominates.

Movable Type

  • Now owned by Six Apart Japan and strong in Japanese corporate sites.
  • The original of "static output plus CMS."

Sanity and Contentful in Japan

  • Sanity has moved aggressively into Japan and competes head-on with microCMS.
  • Contentful's Japanese user base continues to grow.

14. The Korean Market - What's Different

The Korean market has its own peculiarities.

  • NAVER Cafe and Blog - effectively replace some CMS roles. Many content creators still live inside the NAVER ecosystem.
  • In-house CMS - large media and e-commerce players (NAVER, Kakao, Coupang, Woowa Brothers) all run proprietary CMS.
  • Strapi and WordPress dominate SMB - validated for Korean hosting and Korean-language input compatibility.
  • microCMS has minimal Korean presence - beyond the Japanese interface, there is little direct Korean-market support.
  • Korean CMS attempts - Treasure Korea, Modus, and a few others have tried, but share remains low against the global field.

The pattern - Korean teams that adopt open-source headless CMS most often pick Strapi, Payload, TinaCMS in that order, while managed candidates are typically Contentful, Sanity, Storyblok.

15. The Markdown/MDX Side - Contentlayer / Velite / Astro / Nuxt Content

If you define "CMS" broadly, markdown files plus a static site generator also count as a CMS. In 2026 this category is the default for developer blogs and docs.

Contentlayer 2

  • Generates type-safe data from markdown / MDX files.
  • Best fit with Next.js.
  • Official development paused since 2024 - community fork (Contentlayer 2) maintains it.

Velite

  • The de facto successor to Contentlayer. Type-safe plus schema validation (Zod).
  • Excellent build speed.
  • The default pick for new projects since 2025.

Astro Content Collections

  • Built-in content system in Astro.
  • Schema validation, type generation, and auto-routing all included.
  • Used with the documentation theme Starlight.

Nuxt Content

  • The Nuxt (Vue) camp's content system.
  • Markdown plus component embedding plus search, all built in.

Outstatic

  • Next.js-native git-backed CMS.
  • Similar to TinaCMS but lighter.
  • Suits developer blogs and portfolios.

Where MDX sits

  • Markdown plus JSX equals MDX. A first-class citizen in every major static site generator in 2026.
  • Embedding React components inside code blocks creates interactive documents.
  • Downside - strict JSX validation at build time makes it easy for authors to break things (the reason this blog needs its own mdxValidation.ts).

16. Data Models - Document vs Collection vs Block

The heart of a headless CMS is the data model. The standard patterns as of 2026.

Document model (Sanity, Strapi 5)

  • Each piece of content equals one Document.
  • Arbitrary field shape inside a Document.
  • Multilingual and versioning attach to the Document.

Collection model (Directus, Payload, KeystoneJS)

  • Content equals Collection (table) plus Row (item).
  • SQL-friendly; JOINs feel natural.
  • Clear relational modelling.

Block model (Storyblok, Builder.io)

  • Content equals Page plus a Block tree.
  • Visual-editor friendly.
  • Optimal for marketing sites.

Portable Text (Sanity)

  • Rich text as a JSON tree.
  • Can embed arbitrary custom blocks.
  • The most headless-friendly rich-text representation.

Which model to choose

  • Relatively simple content plus multilingual - Document.
  • Relational plus back-office - Collection.
  • Page builder - Block.
  • Long-form arbitrary structure - Portable Text or MDX.

17. APIs - REST vs GraphQL vs GROQ

A headless CMS distinguishes itself by API shape.

APIStrengthsWeaknessesRepresentative products
RESTSimple, cache-friendlyOver/under-fetchingStrapi, Directus, WordPress
GraphQLClient-driven queriesHard to cache, learning curveKeystoneJS, Hygraph, Contentful
GROQGraph traversal, Sanity-onlyLearning curve, no use outside SanitySanity
OData / JSON:APISpec-basedLow shareDrupal JSON:API

The 2026 default is "REST and GraphQL together", letting the client choose.

CDN and caching

The true value of headless is API responses being cacheable at the CDN. Sanity's CDN, Contentful's Edge Cache, Strapi Cloud's caching. For self-hosting, wire up Cloudflare or Fastly directly.

18. Headless E-Commerce - Medusa / Saleor / Crystallize

The line between CMS and e-commerce is blurring. A quick map of headless e-commerce.

Medusa

  • Node.js-based open-source e-commerce backend.
  • Headless plus modular architecture.
  • Rising as the open-source alternative to Shopify.

Saleor

  • Python plus GraphQL based.
  • Enterprise-friendly.
  • Strong multi-channel and multilingual.

Crystallize

  • Headless CMS plus e-commerce hybrid.
  • Treats content and product data with the same model.

The Shopify headless camp

  • Hydrogen plus Oxygen - Shopify's Remix-based headless framework.
  • The content side is often paired with Sanity or Contentful.

Next post candidate

Headless e-commerce deserves its own post. A follow-up will cover Medusa vs Saleor vs Hydrogen plus content-CMS pairing patterns.

19. Recommendations by Use Case - Decision Matrix

Now the blunt recommendations across four domains.

Marketing sites

  • Small (1-3 pages) - TinaCMS or Decap CMS, for the git-backed lightness.
  • Medium (10-50 pages, multilingual) - Strapi 5 or Sanity, for content-model flexibility.
  • Large (block builder, many non-developers) - Storyblok or Builder.io, for the visual editor.

Technical documentation

  • Developer-centric docs - Contentlayer/Velite plus MDX, or Astro Starlight.
  • Large docs (search, multilingual) - TinaCMS plus your own search, or Nextra.
  • Diverse contributors - Decap CMS (Open Authoring).

Mobile-app backends

  • One backend for web plus app plus IoT - Strapi 5 or Directus.
  • TypeScript consistency - Payload 3.
  • Real-time sync needed - Sanity, or a Firebase combination.

E-commerce plus content

  • Shopify users - Hydrogen plus Sanity or Contentful.
  • Open source - Medusa plus Strapi or Payload.
  • Integrated content and product - Crystallize.

Internal back-office plus external API

  • First pick - Directus 11, reusing the existing database.
  • Full-stack integration - Payload 3, sharing a codebase with Next.js.

20. The Decision Checklist

Answering these five questions in order narrows the headless CMS choice by roughly 80%.

  1. Self-host vs managed - do you have infra ops staff, is data sovereignty required?
    • Self-host: Strapi, Directus, Payload, KeystoneJS.
    • Managed: Sanity, Contentful, Storyblok, Hygraph.
  2. Number of content editors - do non-developers handle content daily?
    • Many: Sanity, Storyblok, Strapi.
    • Few / developers only: TinaCMS, Payload, Velite.
  3. Data-model complexity - relational and JOIN-heavy, or page-builder style?
    • Relational: Directus, KeystoneJS, Payload.
    • Page-builder: Storyblok, Builder.io.
    • Long-form: Sanity, Strapi.
  4. Frontend stack - locked to Next.js, or multi-channel?
    • Next.js-first: Payload (Local API), Sanity, Contentlayer/Velite.
    • Multi-channel (web plus app plus signage): Strapi, Sanity, Contentful.
  5. Budget / licensing - is free self-hosting mandatory?
    • Free required: Strapi (CE), Directus, Payload, KeystoneJS, TinaCMS, Decap.
    • Paid acceptable: Sanity (Free to paid), Contentful, Storyblok.

21. Seven Common Mistakes

  1. Assuming "WordPress is finished" - 43% share is still real. Underestimating migration cost is a trap.
  2. Not aligning the data model with code - if the content model is not in the PR flow, operations get heavy.
  3. Treating self-host as zero cost - even Strapi CE needs a DB, Redis, S3, and monitoring.
  4. Assuming GraphQL is always right - REST plus CDN is often faster for marketing sites where caching matters.
  5. Building your own image pipeline - managed image transforms (Sanity, Contentful, DatoCMS) are dramatically faster and cheaper.
  6. Believing the Visual Editor is a panacea - without a design system, the Visual Editor produces inconsistent pages.
  7. Adding multilingual later - i18n is an early data-model decision. Retrofitting it later is migration hell.

22. 2026 Trends - AI, Collaboration, Edge

Three large currents in 2026.

AI content assistants

  • Sanity, Contentful, and Storyblok all integrate AI content generation, summarisation, and translation into the admin.
  • Builder.io has shipped AI page generation (prompt to page tree) as a first-class feature.
  • Strapi adds AI workflows through plugins.

Real-time collaboration goes mainstream

  • The real-time collaboration that Sanity pioneered spreads to Storyblok and Contentful.
  • Strapi and Directus harden their multi-user lock/merge models.

Edge deployment plus content

  • Call CMS APIs directly from Cloudflare Workers, Vercel Edge, and Netlify Edge.
  • Sanity's GROQ is edge-friendly.
  • Contentful and Hygraph offer GraphQL CDNs.

Next post candidates

  • Headless e-commerce deep dive - Medusa / Saleor / Hydrogen real-world comparison.
  • MDX content pipelines - migrating off Contentlayer to Velite / Astro Content.
  • The end of the Visual Editor - real-world operating notes for Storyblok, Builder.io, and Plasmic.

"CMS is no longer a single product category. The answer changes with the team's data model, the number of content editors, and the self-host decision. Trying to handle everything with one tool almost always fails."

— Open Source Headless CMS 2026, end.

References

Discuss on Twitter • View on GitHub