Best Headless CMS for Astro in 2026: From No CMS to Enterprise

I don’t use a CMS for bitdoze.com. I write in VS Code, push to Git, and Cloudflare Pages builds the site. Content lives as MDX files validated by Astro Content Collections with Zod schemas. Zero cost, zero database, zero maintenance.

I migrated from WordPress to Astro using wordpress-export-to-markdown and Codex CLI. The blog runs on Bun for build speed and deploys to Cloudflare Pages. If you’re still picking a framework, I wrote up why Astro beats Next.js and TanStack Start for static content sites.

So why write about headless CMS options for Astro? Because not everyone is a solo dev who’s fine with Git and VS Code. Sometimes you need a browser UI. Sometimes your client needs to edit content. Sometimes you have five writers who don’t know what a pull request is.

Astro’s docs list 40+ CMS integrations. This article cuts that list down to the ones worth your time, starting with the honest baseline: maybe you don’t need one at all.

Do you even need a CMS for Astro?

Astro Content Collections already give you type-safe content management with no extra services. Here’s the pattern used on this site (Astro 5+ content layer with a loader):

// src/content.config.ts
import { defineCollection } from 'astro:content';
import { z } from 'astro/zod';
import { glob } from 'astro/loaders';

const blog = defineCollection({
  loader: glob({ base: './src/content/posts', pattern: '**/*.{md,mdx}' }),
  schema: z.object({
    title: z.string(),
    date: z.coerce.date(),
    description: z.string(),
    draft: z.boolean().default(false),
  }),
});

export const collections = { blog };

That’s a CMS schema. getCollection('blog') is your query layer. Frontmatter is your data layer. VS Code (or any editor) is your UI. Git is your version control.

For a solo dev running a blog or docs site, this covers most of what a Git-based CMS gives you. The missing piece is just a friendlier editing UI.

You can build an Astro blog for free with this stack. If you want an AI-assisted editor, tools like Windsurf or Codex can manage your markdown too. I covered that in building an Astro blog with Windsurf.

Signs you don’t need a CMS:

Signs you do need a CMS:

• Team editing (multiple authors, editors, reviewers)
• Non-technical content editors who need a browser UI
• Structured content types beyond blog posts (products, events, team members)
• Scheduling, approval workflows, or role-based access
• You just prefer a GUI over editing YAML frontmatter

If any of those apply, keep reading.

Git-based CMS vs API-based CMS for Astro

Before picking a tool, pick an architecture. That choice sets your cost, complexity, and ops burden for years.

What are Git-based CMS tools?

A Git-based CMS is a UI layer on top of your Git repository. You define content types (blog posts, pages), and editors get a form or visual interface. When they save, the CMS commits the file to your repo — same as you would from VS Code.

Your content still works with Astro Content Collections. getCollection('blog') reads the same files whether a CMS or a human wrote them. No API calls, no database queries, no runtime dependency on the CMS being online.

The CMS only matters at edit time. At build time, it’s just files.

When an API-based CMS makes sense

Reach for an API CMS when you need things that don’t map cleanly to files:

• Real-time collaboration (multiple people in the same document)
• Complex relationships (related products across thousands of entries)
• Approval chains and scheduled publishing
• Multi-channel delivery (same content to web, app, email)
• A full admin panel with dashboards, analytics, and user management

If you’re looking at self-hosted Strapi or Directus, you’ll need a VPS. Hetzner Cloud has affordable European servers from ~€4/month — that’s what I use for my own fleet. Hostinger VPS is another budget option with KVM and NVMe.

Best Git-based CMS for Astro compared

These fit Astro Content Collections best. Content stays as files, works with getCollection(), and doesn’t need a separate database. Sorted by simplicity, not hype.

Pages CMS: the simplest free option

Pages CMS is what I’d reach for if I needed a CMS on an Astro site tomorrow. Add a .pages.yml config, sign in at app.pagescms.org, edit in the browser. Changes land as Git commits. No npm package, no database, no extra backend.

Stats: ~3.8k GitHub stars, MIT license, TypeScript. Created by Ronan Berder (@hunvreus) in late 2023.

How it works with Astro:

1. Add a .pages.yml at the repo root defining your content types
2. Connect the GitHub repo at app.pagescms.org
3. Edit content in the browser
4. Changes commit to the repo; Cloudflare Pages (or your host) redeploys

Pricing: Fully free. Hosted app.pagescms.org is free. MIT licensed if you want to self-host.

Key features:

• Custom content types via YAML config
• Rich-text editor and Markdown support
• Media uploads (S3, Cloudflare R2)
• Full-text search across content
• Scheduling and granular access control
• Inline comments for review
• Email invites, so editors don’t need a GitHub account

Setup checklist:

Limitations:

• No embeddable /admin route — the CMS is a separate site (app.pagescms.org or your self-hosted instance)
• No repeater fields (still true as of mid-2026)
• Form-based editor only, not WYSIWYG-on-the-page
• GitHub only — no GitLab or Bitbucket yet
• Solo maintainer, so there’s bus-factor risk. If the project stalls, your content is safe (it’s just files in Git), but you lose the editing UI

Self-hosting: Needs PostgreSQL, Docker, and a GitHub App. The self-hosting docs cover it. If you already run Dokploy or Docker Compose on a VPS, it’s straightforward.

What users say: Reddit feedback is mostly positive: “Really really easy to set up… exactly what I need.” The usual complaint is that it’s a separate website rather than an embedded admin, which some freelancers dislike for client handoffs.

Verify it works: After adding .pages.yml, open app.pagescms.org and confirm your repo appears. Create a test post and check that the commit shows up in Git history.

Keystatic — TypeScript-native with first-class Astro support

Keystatic comes from Thinkmill (the KeystoneJS team). Everything is configured in TypeScript, and the admin UI lives at /keystatic inside your Astro project.

Stats: ~2.2k GitHub stars, MIT license, TypeScript. Started early 2023.

How it works with Astro:

1. Install @keystatic/core + @keystatic/astro + @astrojs/react + @astrojs/markdoc
2. Define collections and singletons in keystatic.config.ts
3. Content stored as Markdoc (.mdoc), YAML, or JSON in your repo
4. Admin UI at /keystatic

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

export default config({
  storage: { kind: 'local' },
  collections: {
    posts: collection({
      label: 'Posts',
      slugField: 'title',
      path: 'src/content/posts/*',
      format: { contentField: 'content' },
      schema: {
        title: fields.slug({ name: { label: 'Title' } }),
        content: fields.markdoc({ label: 'Content' }),
      },
    }),
  },
});

Pricing: Free for local and GitHub workflows. Keystatic Cloud (optional): free up to 3 users/team; Pro at $10/month/team + $5/user beyond 3. Cloud adds GitHub auth, Cloud Images (CDN), and experimental multi-player editing.

Why I’d consider Keystatic: The TypeScript config is actually pleasant to work with. Collections, singletons, and the Reader API keep content type-safe without leaving your editor. If you’re already using Bun for faster Astro builds, it fits that workflow.

Limitations:

• React dependency for the Admin UI — adds weight if your site is otherwise React-free
• Content auto-creates in sub-folders based on slug, which confuses a lot of people
• ~174 open GitHub issues (mid-2026)
• Some Reddit users found it “surprisingly difficult to figure out”

What users say: “Surprisingly difficult… main problem was not knowing how to make posts without auto-generated sub folders… user error but real pain. Really wanted to love this one.” Devs who like TypeScript-first tools tend to stick with it; people who want a five-minute visual setup often bounce.

Verify it works: After install, open /keystatic and confirm the admin loads. Create a test post and check the file lands in your content directory with the right schema.

TinaCMS — visual editing for teams

TinaCMS has the most GitHub stars among Git-based options here. SSW (Australian consultancy) maintains it. The headline feature is visual editing: editors see changes on the actual page, not only in a form.

Stats: ~13.7k GitHub stars, Apache 2.0, TypeScript. Started mid-2019.

How it works: Git-based with a GraphQL layer. Content in Markdown/MDX/JSON/YAML. Astro is a first-class starter (they made it a default option around 2024). Install with npx create-tina-app@latest and pick the Astro starter.

Pricing (TinaCloud), per project:

• Free: $0 forever, 2 users, 2 roles, community support
• Team: $24/month ($290/year), 3 users included, up to 10
• Team Plus: $41/month ($490/year), 5 users included, up to 20, Editorial Workflow
• Business: $249/month ($2,990/year), 20 users included, unlimited seats

Tina has said the vast majority of users stay on free.

Limitations:

• ~430+ open GitHub issues
• Free tier stops at 2 users — third editor means Team at $24/month
• Visual editing features need TinaCloud
• Heavier dependency tree than Pages CMS or Keystatic

Verify it works: Run npx create-tina-app@latest with the Astro starter. Confirm the visual editor loads and you can create/edit a post with live preview.

Decap CMS and Sveltia CMS — the open-source workhorses

Decap CMS (formerly Netlify CMS) is the old default for Git-based CMS. ~19.3k GitHub stars, MIT. Around since 2015. Netlify dropped official support; the community fork (Decap) keeps it alive at a slower pace. The UI feels dated next to newer tools.

Sveltia CMS (~2.6k GitHub stars, MIT) is a drop-in replacement for Decap. Same config format, same Git model, but faster, modern UI, mobile support, and built-in i18n. Already on Decap and hate the UI? Swap the script include. Done.

Both work via CDN include — no npm package. Config file + script tag. Content still works with getCollection() because it’s just files.

Limitation: Neither does visual editing. Form-based only, similar to Pages CMS. Auth still inherits Decap’s Netlify-era design, which is the main source of frustration.

Verify it works: After config, open /admin and complete the GitHub OAuth flow. Create a test post and check the Git commit.

CloudCannon — visual editing for client handoffs

CloudCannon is the premium Git-based CMS. Featured partner on Astro’s docs, and one of the polished visual editing experiences in the Git-based space. Content stays in your repo. Branch-based editing and publishing.

Pricing:

• Standard: $55/month
• Partner Program Lite: $10/month per client (for freelancers/agencies)

Built-in image optimization, DAM connectors, content scheduling, and solid Astro integration with component starters.

Limitations: Proprietary. Content is in Git, but the visual editor is CloudCannon’s product. Leave and you keep the files, lose the workflow. At $55/month standard, it’s steep for solo projects. Partner pricing ($10/client) is the interesting number if you ship client sites regularly.

Vendor lock-in: Content is yours. The editing workflow is not. Price hike or shutdown means finding a new UI, not a content migration.

Front Matter CMS — the VS Code extension

Front Matter CMS is a free VS Code extension: content dashboard, media management, SEO checks, content types, and a frontmatter panel — all inside the editor.

Pricing: Free. MIT licensed.

Closest thing to “no CMS, slightly nicer.” Great for solo devs who want a sidebar without jumping to a browser. Useless for teams or non-technical editors — everyone needs VS Code.

Works in Windsurf and other VS Code forks. Pair it with AI-assisted editing if you like that workflow.

Verify it works: Install from the VS Code marketplace. Confirm the sidebar dashboard lists your content files.

StudioCMS — Astro-native

StudioCMS is built by the Astro community for Astro. It left beta in January 2026 (v0.1.0). Dashboard, storage API, taxonomy, and an SSR-focused design aimed at the Astro ecosystem.

Stats: ~800 GitHub stars. Still young, but no longer “don’t touch production.”

Worth a look if you want Astro-only tooling and are fine with a project that just left beta. For client work or high-stakes sites, I’d still pick something more battle-tested (Pages CMS, Keystatic, Tina, CloudCannon). For a personal project or early adopter site, give it a try.

Best API-based headless CMS for Astro

These need a separate backend. More power for complex models, teams, and enterprise. If you’re running a simple blog, this section is overkill — use a Git-based option above.

Self-hosting? You’ll need a VPS. Hetzner Cloud from ~€4/month. Vultr if you want more regions.

Sanity — most customizable studio

Sanity has an official Astro plugin and a highly customizable admin Studio. Portable Text for structured rich content, real-time collaboration, image CDN with auto WebP/AVIF, GROQ, React-based Studio you can shape to your content model.

Pricing: Free plan is usable (up to 20 seats with limited roles). Growth is $15 per seat / month, not a flat $15.

The catch: Almost everything is DIY. You get a lot of control, and you wire most of it yourself. Great if you enjoy building custom editing UIs. Painful if you just want to ship a blog.

Verify it works: Set up Studio + the Astro plugin, create a test entry, and confirm the page renders it through the plugin’s data fetching.

Strapi and Payload — self-hosted open source

Strapi is the big open-source headless CMS (~73k GitHub stars). Customizable admin, REST + GraphQL, role-based permissions. Self-hosted free. Needs Node.js and a database on a VPS.

Payload is newer and well-liked for content modeling and extensibility (~44k stars). Also self-hosted and free at the core.

Both make sense when you want a full admin panel and API. For a static Astro blog, the ops work (VPS, database, backups, updates, security) rarely pays for itself.

Verify it works: After Docker deploy, open the admin URL, create a test entry, hit the API endpoint.

Failure mode: If the VPS dies, builds that fetch content fail. Plan monitoring and backups.

Storyblok — best visual editor

Storyblok has an official Astro SDK and one of the best visual editors in headless CMS. Closest feeling to WordPress for non-technical editors: click a component on the page, edit inline. Component-based “Bloks” inside rich text.

Pricing:

• Starter (free): 1 seat, limited traffic/API
• Growth: $99/month (5 seats)
• Growth Plus: $349/month (15 seats)
• Extra seats: $15/month

Astro integration is maintained. If you’re handing a site to a client who knows WordPress, Storyblok will feel familiar.

Limitation: SaaS only. No self-hosting. You’re on their pricing for the long haul.

Contentful — enterprise-ready but watch pricing

Contentful is strong for enterprise: content modeling, workflows, roles, multilingual, DAM, reliable APIs. I’ve covered Contentful with Astro before.

Limitations: Awkward mid-article component insertion and rigid text-block handling. Solid as an API-first backend; authoring UX trails Storyblok for everyday content work.

Directus — wrap any database

Directus is open-source and self-hosted. It wraps SQL databases (PostgreSQL, MySQL, SQLite, etc.) with REST + GraphQL and an admin panel. Real-time subscriptions, granular permissions, Flows (automation).

Good fit when you already have data in SQL and want a CMS on top. Core self-hosted is free. Cloud is a paid add-on (plans start higher than most solo budgets — check current pricing before you plan around it).

Failure mode: Same VPS maintenance as Strapi/Payload. CMS down at build time = failed deploy.

BCMS — avoid for new projects

BCMS (~460 stars, MIT) looked fine on paper: modern UI, flexible modeling, Next/Astro/Svelte. The core team moved development private in September 2024. No updates, fixes, or security patches on the open repo.

Skip it for new Astro work. The BCMS site now markets a “headless CMS for AI agents” direction, which is a different product.

Already on BCMS? Content is safe if you self-host, but you’re on unsupported code. Plan a migration.

Pricing comparison: what each CMS actually costs

CMS	Type	Free Tier	Entry Paid	Self-Hosted?
No CMS (MDX + Git)	Files	✅ $0/month	$0	N/A
Pages CMS	Git-based	✅ Everything free	$0	✅ (needs PostgreSQL)
Keystatic	Git-based	✅ Up to 3 users	$10/month + $5/user	✅ (core is free)
TinaCMS	Git-based	✅ 2 users	$24/month (3 users)	⚠️ Complex
Decap CMS	Git-based	✅ Everything free	$0	✅ (decoupled auth)
Sveltia CMS	Git-based	✅ Everything free	$0	N/A (CDN-hosted SPA)
CloudCannon	Git-based	❌ No free tier	$55/month ($10 partner)	❌ SaaS only
Front Matter CMS	Git-based (VS Code)	✅ Everything free	$0	N/A (extension)
StudioCMS	Astro-native	✅ Free	$0	✅ (own stack / Astro)
Sanity	API-based	✅ Free plan (seats limited)	$15/seat/month	Studio self-hostable; Content Lake is SaaS
Storyblok	API-based	✅ Starter (1 user)	Growth: $99/mo (5 seats)	❌ SaaS only
Contentful	API-based	✅ Free tier	Escalates fast	❌ SaaS only
Strapi	API-based	✅ Self-hosted free	Cloud plans vary	✅ (VPS needed)
Payload	API-based	✅ Self-hosted free	Cloud plans vary	✅ (VPS needed)
Directus	API-based	✅ Self-hosted free	Cloud add-on (check current)	✅ (VPS needed)
BCMS	API-based	⚠️ Frozen OSS	Pro: unclear	✅ (MongoDB + Docker)

Hidden costs:

• Self-hosted API CMS: $4–20/month VPS + setup, backups, updates
• Git-based CMS with image uploads: S3/R2 storage, or repo bloat if you commit binaries
• Keystatic Cloud Images: Pro plan feature, external dependency
• CloudCannon: $55/month standard, or $10/client on Partner Program

How to pick the right CMS for your Astro project

Two questions matter: who edits content and where content lives.

Decision matrix

Scenario	Best pick	Why
Solo dev, personal blog	No CMS (MDX + Git)	$0, zero complexity
Solo dev, wants browser UI	Pages CMS	Free, simple, no npm
Solo dev, wants TypeScript config	Keystatic	First-class Astro, type-safe
Team of 3–5, budget	Pages CMS	Free, email invites
Team of 3–5, visual editing	TinaCMS	Visual editor, $24/month
Client handoff, budget	CloudCannon Partner	$10/month per client
Client handoff, premium	Storyblok	Strong visual editor
Complex content models	Sanity or Strapi	Full API, custom types
Enterprise, multi-channel	Contentful or DatoCMS	Proven at scale

Common pitfalls when adding a CMS to Astro

Failure modes I keep seeing:

1. Decap CMS auth is a time sink. Netlify Identity is deprecated. Auth0 is heavy. Starting fresh? Pages CMS or Keystatic. Stuck on Decap? GitHub OAuth + DecapBridge.

2. Keystatic sub-folder confusion. Content auto-creates folders from slugs. Flat structure under src/content/posts/ needs careful path config. The TypeScript config is powerful and easy to misconfigure.

3. TinaCMS dependency conflicts. Version clashes with Astro and other packages show up often. Smoke-test with npx create-tina-app@latest before committing. Pin versions if things break.

4. BCMS open-source is dead. Don’t start new projects on it. Frozen since October 2024.

5. Contentful pricing scales harshly. Free is fine for small sites. Higher traffic/usage can jump to enterprise pricing. Check usage early.

6. API CMS = single point of failure. Backend down at build time = failed deploy. For static sites your pipeline depends on that service. Monitor it, and keep a plan for stale builds. If you’re deploying to Cloudflare Pages, recent cached builds can buy time — only if you’ve deployed recently.

Frequently asked questions

Do I really need a CMS for Astro?

No. Content Collections with Zod and MDX give you type-safe, validated content with no extra services. Solo blog or docs site? That’s enough. The CMS is a UI layer. If you’re fine with VS Code and Git, skip it. bitdoze.com runs that way.

What's the cheapest headless CMS for Astro?

Pages CMS is free end-to-end (hosted + MIT). Front Matter CMS is free as a VS Code extension. No CMS at all is also $0. For API options, self-hosted Strapi and Payload are free but need a VPS (~$4–20/month).

Can I self-host a headless CMS on my VPS?

Yes. Pages CMS, Strapi, Directus, and Payload all support it. Plan for at least 2GB RAM for Strapi/Directus. A Hetzner CX22 (~€5/month) covers low-traffic self-hosted CMSes. You still own Docker, backups, and security updates. If you already run Dokploy or similar self-hosted panels, adding a CMS container is straightforward.

Keystatic vs TinaCMS — which is better for Astro?

Keystatic if you want TypeScript config and a clean /keystatic admin. TinaCMS if the team needs visual editing on the live page. Keystatic is lighter (no TinaCloud required) but needs an SSR adapter. Tina has more features, more dependencies, and costs more once you leave the free tier.

Is BCMS still a good choice?

No. Open-source has been frozen since October 2024. The README says no further updates. BCMS Pro is closed-source with unclear pricing. For new Astro projects use Pages CMS, Keystatic, or another active project.

How do I handle images without bloating my Git repo?

Use an external CDN. Bunny.net storage is about $0.01/GB/month with a global CDN. Pages CMS supports S3 and Cloudflare R2. Keystatic Cloud Images is on the Pro plan. Cloudinary has a useful free tier. For faster Astro builds, a lean repo still matters — large image directories slow clone and build times.

Wrapping up

The best headless CMS for Astro might be no CMS at all. That’s how I run this blog. Content Collections + MDX + Git give you type-safe content for $0 with nothing to babysit.

When you do need a CMS — team editing, non-technical editors, client handoffs — Git-based tools line up better with Astro’s architecture. Pages CMS is the simplest free option. Keystatic if you want TypeScript-native config and first-class Astro support. TinaCMS if you need visual editing. CloudCannon for client handoffs.

Only go API-based when you need real-time collaboration, complex models, or enterprise features — and budget for VPS, database, backups, and monitoring if you self-host.

Pick based on who edits your content, not which product has the longest feature list.

Migrated from WordPress? Start here