Skip to content
The directory

Headless CMS platforms, compared on what they really cost

55 platforms, researched from their own pricing pages and their own LICENSE files rather than their marketing. What each one charges once your team grows, where it actually runs, whether you can host it yourself, and which licence you are really agreeing to.

55
platforms reviewed
24
genuinely open source
31
you can self-host
48
usable free
The directory

Every platform, filtered by how it runs

Filters are on the left. Hosting is the one worth starting with, because it decides who carries the operations and that is harder to change later than any feature.

All 55 headless CMS platforms below were checked against their own pricing pages and, where the code is public, their own LICENSE files rather than a comparison post. Two of the headless CMS options here are described as open source almost everywhere and are not, which is the kind of thing only the licence file tells you.

Showing 15 of 55 platforms

Payload

Featured

Best for Next.js teams who want to own the database

A MIT-licensed CMS that installs into your Next.js app rather than sitting beside it. Config is TypeScript, the admin panel is generated from it, and the database is yours.

  • Runs inside your Next.js app, same repo and same deploy
  • Postgres, MongoDB or SQLite, your instance
  • Admin UI generated from a TypeScript config
  • Next.js
  • React
  • GraphQL API
  • TypeScript / Next.js
FreeCloud or self-hosted · Open source

Best for structured content at scale

The structured-content platform behind a large share of serious Next.js marketing sites. You build the editing Studio as React code in your own repository; Sanity hosts the content and serves it over GROQ.

  • GROQ query language, plus a GraphQL API you deploy per dataset
  • Studio is React code in your repo, not a hosted form builder
  • Image CDN with on-the-fly transforms and hotspot cropping
  • Next.js
  • React
  • Vue / Nuxt
  • TypeScript / React (Studio)
$0Managed SaaS · Proprietary

Best open-source all-rounder

The most-installed open-source headless CMS. Node.js, a point-and-click content-type builder, REST and GraphQL out of the box, and a managed cloud if you would rather not run it.

  • Content-type builder in the admin UI, no code required
  • REST and GraphQL generated automatically
  • Self-host free, or Strapi Cloud from $35 per project
  • React
  • Vue / Nuxt
  • Svelte / SvelteKit
  • JavaScript / Node.js
FreeCloud or self-hosted · Open source

Best for enterprise governance

The enterprise default. Mature APIs, serious governance and localisation, an official MCP server, and a pricing model that jumps from free to $300 a month with nothing in between.

  • Content Delivery, Preview and Management APIs
  • Environments and environment aliases for safe schema changes
  • Deep localisation and role-based governance
  • Next.js
  • React
  • Vue / Nuxt
  • Hosted SaaS
$0Managed SaaS · Proprietary

Best visual editing for marketers

The best visual editor in the category. Component-based content with a real-time side-by-side preview, which is what makes it the usual pick when marketers, not developers, will be doing the work.

  • Side-by-side visual editor against a live preview
  • Component-based blocks that map to front-end components
  • Free tier with 1 seat, then $99/mo for 5
  • Next.js
  • React
  • Vue / Nuxt
  • Hosted SaaS
$0Managed SaaS · Proprietary

Best GraphQL-native option

GraphQL-native from the ground up, with content federation that pulls remote sources into the same query. The pick when the CMS has to sit in front of systems it does not own.

  • GraphQL-first API, not a REST wrapper
  • Content federation across remote REST and GraphQL sources
  • Free Hobby tier with 3 seats and 500k API calls
  • Next.js
  • React
  • Vue / Nuxt
  • Hosted SaaS
$0Managed SaaS · Proprietary

Best for an existing SQL database

Wraps any SQL database in an instant REST and GraphQL API plus an admin app, without moving your data. As of 2026 it is source-available rather than open source, which is worth knowing before you commit.

  • Points at an existing SQL database and mirrors the schema
  • Instant REST and GraphQL over any table
  • Official MCP server
  • Next.js
  • React
  • Vue / Nuxt
  • TypeScript / Node.js
FreeCloud or self-hosted · Source available

Best for publications and newsletters

A publishing platform with memberships and newsletters built in, that also exposes a read-only Content API. The best option here if the content is a publication rather than a website.

  • Memberships, paid subscriptions and email newsletters built in
  • Read-only Content API for headless front ends
  • MIT licensed and self-hostable
  • Next.js
  • React
  • Astro
  • JavaScript / Node.js
FreeCloud or self-hosted · Open source

Cheapest realistic paid entry

Page-building through reusable slices, with the cheapest realistic paid entry point in the directory at $10 a month and unlimited documents on every tier.

  • Slices: reusable page sections shared by editors and developers
  • Unlimited documents on every plan, including free
  • 4 million API calls a month even on the free tier
  • Next.js
  • React
  • Vue / Nuxt
  • Hosted SaaS
$0Managed SaaS · Proprietary

Best media pipeline

A polished GraphQL CMS with the best image pipeline in the category, and a genuine focus on performance: responsive images, LQIP placeholders and video encoding come as standard.

  • GraphQL Content Delivery API with real-time updates
  • Image CDN with responsive srcsets and blur-up placeholders
  • Video streaming and encoding included
  • Next.js
  • React
  • Vue / Nuxt
  • Hosted SaaS
$0Managed SaaS · Proprietary

Best for marketer-built landing pages

Visual, drag-and-drop page building bound to your real front-end components, now wrapped in an AI design-to-code product. Marketers ship pages; developers keep the component library.

  • Drag-and-drop editor bound to your React components
  • AI design-to-code from Figma
  • A/B testing and targeting built in
  • Next.js
  • React
  • Vue / Nuxt
  • Hosted SaaS
$0Managed SaaS · Proprietary

Best git-backed visual editing

Git-backed editing with a visual sidebar. Content stays as Markdown or JSON in your repository, every edit is a commit, and TinaCloud handles auth and the editing API.

  • Content lives in your git repo as Markdown or JSON
  • Visual editing with a live sidebar over your site
  • Every change is a commit, so review and rollback are git
  • Next.js
  • React
  • Astro
  • TypeScript / Node.js
$0Cloud or self-hosted · Git-based · Open source

Free git-based editing

The original git-based CMS, formerly Netlify CMS. A single-page admin app you drop into your site that commits Markdown to your repo. Free, MIT, and completely self-contained.

  • Drops into any static site as one admin route
  • Commits Markdown and media straight to git
  • MIT licensed with no hosted dependency
  • React
  • Next.js
  • Astro
  • JavaScript / React
FreeSelf-hosted · Git-based · Open source

Familiar editor, existing content

The most familiar admin interface in the world, used as a content API. The built-in REST API works out of the box; WPGraphQL is what most headless builds actually run on.

  • REST API included in core, no plugin required
  • WPGraphQL for a proper typed GraphQL layer
  • Editors already know the interface
  • Next.js
  • React
  • Vue / Nuxt
  • PHP
FreeCloud or self-hosted · Open source

Best editor experience in PHP

A PHP CMS with an outstanding editor experience and a GraphQL API for headless use. Licensed per project as a one-off rather than a subscription, which changes the economics entirely.

  • Best-in-class content modelling for a PHP CMS
  • GraphQL API for headless front ends
  • One-off per-project licence, not a subscription
  • Next.js
  • React
  • Vue / Nuxt
  • PHP / Yii
FreeCloud or self-hosted · Source available
Side by side

The six most-used, compared

Our featured pick leads. Every value below derives from the same fields as the cards above, so the table cannot disagree with them.

The headless CMS features that end up mattering are rarely the ones on a vendor's homepage. Visual editing, localisation and workflow separate these six far more than API design does, and the headless CMS solutions that win a shortlist usually win it on the editor's experience rather than the developer's.

Compare
Entry price
Free
$0
Free
$0
$0
$0
Hosting
Cloud or self-hosted · Open source
Managed SaaS · Proprietary
Cloud or self-hosted · Open source
Managed SaaS · Proprietary
Managed SaaS · Proprietary
Managed SaaS · Proprietary
Licence
Open source
Proprietary
Open source
Proprietary
Proprietary
Proprietary
Self-hostable
Free tier
Free forever, self-hosted, MIT licence
20 seats, 10k documents, 250k API requests/mo, forever
Self-hosted Community edition, MIT
10 users, 100k API calls/mo, 10k records, 2 locales
1 seat, 1 space, 100k API requests/mo, 100GB traffic
3 seats, 1,000 entries, 500k API calls/mo
GraphQL
Next.js toolkit
Visual editing
Localization
Workflows & roles
Media CDN
Vendor MCP server

Entry prices are the cheapest published route to a working install, read from each vendor's own pricing page in August 2026. Licences were read from each repository's LICENSE file. Both move, so confirm before you budget.

Buyer's guide

How to choose between headless CMS platforms

Six things that decide whether a platform fits, in the order they usually bite. Every figure below is computed from the directory above.

01

Be specific about which benefit you are buying

The headless CMS benefits people list in the abstract, meaning speed, flexibility and omnichannel delivery, are all real and none of them is why a particular team should switch. Decoupling buys you one concrete thing: the CMS stops deciding how your pages are rendered. Everything else follows from that, and so does the entire cost, because you now own the front end that used to come free.

If your current problem is that editors cannot ship a landing page without a developer, decoupling makes that worse, not better, unless you also buy visual editing. Only 22 of the 55 platforms here carry it.

02

Where it runs decides who carries the risk

33 of these are managed SaaS, where the vendor owns uptime, scaling and the rate limits you live inside. 31can be run on your own infrastructure, which moves all three onto your team and removes them from someone else's pricing page. 9 store content in a git repository instead of a database, which makes review and rollback free and concurrent editing hard.

There is no right answer, but there is a wrong process: picking on features and discovering the hosting model afterwards. It is the first filter for a reason.

03

Read the licence, not the marketing

24 of the 55 platforms here ship under a genuine open-source licence. Another 5 are source-available, which is a different thing: you can read and usually modify the code, but the licence restricts what you may do with it commercially.

This is not academic. Directus moved to the Monospace Sustainable Core License in 2026 and is still widely described as open source. dotCMS is free in production only while your total finances stay under $5m a year. Both facts come from the LICENSE file, not the homepage.

04

Model the price on your team, not your traffic

48 of the 55 can be run at no cost, either through a real free tier or an open-source licence you self-host. At the other end, several require four-figure monthly commitments before publishing a page.

The trap is the billing axis. Seats, records, API calls, locales and environments are all metered by somebody here, and the one that bites is rarely the one on the comparison page you read.

Select a band to see which of the 55 platforms sit in it. Several span more than one, so the counts add up to more than 55.

05

Check the API shape against your stack

39 of the 55 expose GraphQL and 49 ship a first-party Next.js toolkit, but the two lists are not the same and the gaps matter. A GraphQL-only platform is a hard blocker for a service that cannot speak it, and a REST-only platform will over-fetch on every page unless you build a layer to stop it.

If localisation is in scope, check it early rather than late: 45 platforms carry it, and among those the difference between field-level translation and a separate copy of the site is enormous.

06

Ask what the exit looks like

Every platform here will export your content. What none of them export is the query language, the rich-text format and the front-end code shaped around them. That is the real switching cost, and it is measured in weeks of engineering rather than in a data migration.

One new signal worth noting: 4 of these vendors now ship their own Model Context Protocol server, which lets an AI client read and write content directly. Favour platforms whose content model you could describe to a new developer in ten minutes. That is usually the same list as the ones you can leave.

The part nobody plans for

What changes for SEO when you go headless

Going headless does not help or hurt rankings by itself. What it does is move five specific responsibilities from a plugin to your codebase, and headless CMS SEO problems are almost always one of those five being nobody's job.

We have shipped all five wrong at least once, including on this site. The streaming-metadata one below took a Screaming Frog crawl reporting missing titles on roughly one page in eight to find.

Talk through your migration
  • 01

    Nothing renders your metadata any more

    In a coupled CMS, a plugin writes the title, description, canonical and Open Graph tags into the page. Decouple, and that plugin is still storing those fields but nothing is emitting them. This is the single most common way a headless migration loses rankings, and it is invisible in the CMS because the fields still look filled in.

    What to doQuery the SEO fields explicitly and emit them from the framework's own metadata API. Then diff the rendered <head> of ten old URLs against ten new ones before cutover.

  • 02

    You now choose the rendering mode, and it shows

    Static, incrementally revalidated, streamed and fully dynamic all produce different time to first byte and different behaviour for crawlers that do not execute JavaScript. A CMS cannot make that choice for you once it is headless, so it becomes a decision somebody has to make deliberately per route.

    What to doPrerender anything with organic intent. Reserve dynamic rendering for pages behind a login, where crawlers are not going anyway.

  • 03

    Async metadata can land in the body

    Next.js streams metadata on dynamically rendered routes, which means </head> can flush before an async CMS query resolves and the title and canonical get emitted into <body> instead. It only fails for user agents outside the framework's html-limited-bots list, which excludes Screaming Frog, Ahrefs, Semrush and the AI crawlers. It is intermittent, so a crawl catches a different page every run.

    What to doPrerender the route. Buffered HTML has a complete head by construction, which fixes the race rather than papering over it.

  • 04

    Sitemaps and redirects become your code

    The CMS used to generate the sitemap and honour the redirect table. Headless, both are files or route handlers in your repository, and neither fails loudly when it drifts. A missing redirect map at cutover is how a migration loses the equity of every URL it changes.

    What to doGenerate the sitemap from the same query that lists published content, and hold redirects in code so they are reviewed like code.

  • 05

    Structured data has to come from somewhere

    Article, FAQPage, BreadcrumbList and Product markup were plugin output before. Now they are your responsibility, which is an improvement, because you can emit exactly what is on the page rather than what a plugin guesses. It is only an improvement if somebody actually does it.

    What to doBuild the schema from the same fields the page renders, so markup and content cannot disagree, and validate the prerendered HTML rather than the preview.

Straight from Reddit

What developers actually say

Real, unedited comments from r/webdev, r/nextjs, r/cms, r/PayloadCMS and r/Strapi on picking one, migrating to it, what it cost and what it is like to edit in. Every card links to the original.

Comments are quoted from public Reddit threads and belong to their authors. Opinions are their own, shared here for context, not endorsements.

Use cases

What teams actually build

Each tile filters the directory to the platforms that fit.

Most headless CMS examples you find online are a blog with three posts, which proves nothing about the decision. These are the six shapes that actually recur, and the count on each tile is computed from the directory rather than asserted.

The first two tiles look like one question and are not. People searching nextjs headless cms are usually choosing how pages get rendered and who owns the metadata; people searching react headless cms are usually building an application and care about typed clients and what a server component can call. The shortlists overlap, the deciding criteria do not.

Migration

What a migration actually takes

A headless CMS implementation for a normal marketing site is about four weeks of work, and roughly a third of it is not the CMS at all. These are the stages in the order they bite, with what each one should actually produce. Treat the weeks as the shape rather than the quote: a site with three page types and one editor is faster, and a multi-brand estate with 4,000 URLs is not.

  1. 01Week 1

    Model the content, not the pages

    The first mistake is modelling what the current site looks like instead of what the content is. Get this wrong and every future page type is a schema migration.

    Content types
    6 to 12
    Reference graph
    drawn
    Reviewed by
    editors
  2. 02Weeks 1 to 2

    Migrate the content, with the URLs

    Content moves through a script, not by hand, so it can be run twice. The redirect map is built in the same pass, because the old URL is only knowable while you still have the old system.

    Import script
    idempotent
    Redirect map
    1:1
    Dry run
    before cutover
  3. 03Weeks 2 to 3

    Build the front end and the head

    Templates, components and the metadata layer together. The metadata is not a finishing task: titles, canonicals, sitemap and structured data are wired as each template is built, not audited afterwards.

    Prerendered routes
    all indexable
    Metadata source
    CMS fields
    Schema
    from the same data
  4. 04Week 3

    Hand it to the editors before launch

    The migration that fails is the one where editors first use the CMS the week after go-live. Give them the real thing with the real content and fix what they trip over while it is still cheap.

    Editor session
    recorded
    Fields renamed
    usually several
    Preview
    working
  5. 05Week 4

    Cut over and watch the crawl

    Redirects live, sitemap submitted, then a full crawl of the new site compared against a crawl of the old one. Rankings move for a fortnight either way; missing titles do not fix themselves.

    Crawl diff
    old vs new
    Head check
    title, canonical
    Search Console
    resubmitted
Methodology

How we picked, and what we checked

This is a shortlist, not a census. We started from the platforms that actually come up when engineering and marketing teams pick one, then cut it to the ones with public documentation and a callable API. Nobody can tell you the best headless CMS in the abstract, because the answer changes with who is editing and who is on call, so the headless CMS platforms here are sorted by the constraints that decide it rather than ranked.

Every price was read from the vendor's own pricing page in August 2026, not from a comparison article. Where a vendor publishes no public rate, we say so rather than repeating a number from somebody's negotiated deal. 5 of the 55 publish nothing at all.

Licences were read from each repository's LICENSE file rather than from the marketing site. That is how Directus, dotCMS, Craft, Statamic and Pimcore ended up classified the way they are, and it is the single most common thing comparison posts get wrong.

No affiliate links and no paid placements. Nobody here pays to be listed, to be featured, or to rank higher in the directory. Outbound links carry nofollow and we earn nothing if you sign up.

Our featured pick is what we run ourselves. busyless.space is a Next.js app with Payload installed into it, and Payload is the platform we feature. State the obvious: that is a conflict, and you should read the review knowing it. The order it happened in was that we picked it for our own site, lived with it, and the recommendation followed. Nobody paid for it.

The honest counterweight is that the reason it suits us is not a reason it will suit you. We have developers, so running a database is a cost we already carry. If you do not, Sanity is the better answer and the one we recommend most often to clients, whatever the badge on this page says.

No invented ratings. We publish no star rating and no aggregate score. The scorecard on our featured review is an editorial read across six dimensions and it stays out of the page's structured data. Reddit comments are quoted for context and linked to the original, never restated as fact.

FAQ

Questions we get

  • What is a headless CMS?
    A content system that stores and serves content through an API and does not render your pages. You model the content, editors fill it in, and your own front end decides how it is displayed. The trade is that you gain complete control of rendering and lose the templates that used to come with the CMS.
  • Which one should I choose?
    Start with where it has to run, because that is the constraint you cannot engineer around. If it must be your own infrastructure, Payload is our featured pick and you are otherwise choosing between Strapi, Directus and the other self-hostable options. If a vendor can host it, Sanity is the strongest option for structured content, Storyblok for marketing teams who need visual editing, and Contentful when governance and procurement decide.
  • Is there a genuinely free option?
    Several, and they split into two kinds. Open-source tools like Payload, Strapi, Keystone and Wagtail are free forever if you run them yourself, so you pay for hosting instead of licences. Hosted platforms with real free tiers include Sanity at 20 seats and 10,000 documents, Prismic with unlimited documents and 4 million API calls, and Hygraph at 3 seats and 500,000 calls.
  • Which ones work with Next.js?
    Most of them, and the list is long enough that it should not be your deciding filter. What actually varies is the quality of the integration: whether draft mode and tag-based revalidation are supported, whether there is a first-party toolkit, and whether visual editing works against a live preview. Sanity, Storyblok, Payload, Contentful and Prismic are the strongest on that axis.
  • Open source or hosted?
    It is a question about who carries the operations, not about the software. Self-hosting means your database, your backups, your upgrades and your uptime, in exchange for no seat limits, no request metering and no pricing changes. Hosted means a vendor takes all of that and prices it. Teams without a developer who will own infrastructure should not self-host, whatever the licence says.
  • Does going headless help SEO?
    Not by itself. It moves responsibility for titles, canonicals, sitemaps, redirects and structured data out of a plugin and into your codebase. Done deliberately that is an improvement, because you emit exactly what is on the page. Done by accident it is the most common way a migration loses traffic, because the fields still look filled in while nothing is rendering them.
  • How long does a migration take?
    About four weeks for a normal marketing site: a week to model the content, a week or two to migrate it with a one-to-one redirect map, a week on templates and the metadata layer, and a final week of editor testing and cutover. A site with three page types is faster. A multi-brand estate with thousands of URLs is a different conversation.
  • What is the difference between open source and source available?
    An open-source licence lets you use the software for any purpose, including competing with the people who wrote it. Source-available licences such as BSL, ELv2 and Directus's MSCL let you read and usually modify the code but restrict commercial use. It matters more than it sounds: Directus moved to a source-available licence in 2026 and dotCMS is free in production only under a $5m revenue threshold.

Picked one? The build is the other half.

Choosing the platform is the easy part. We do the rest: the content model, the migration with its redirect map, the front end, and the metadata and schema layer that decides whether the new site keeps the traffic the old one earned. Usually live in weeks, not quarters.