Best CMS for Astro

Astro is the fastest-growing meta-framework in the JavaScript ecosystem — and most CMS comparisons still pretend it doesn't exist. If you're building a content site with Astro in 2026 and trying to figure out which CMS won't fight you, this page is for you. Honest breakdown of seven options that actually work with Astro: what they cost, where they break, and which one fits your project.

TL;DR: For most Astro sites, three options matter: Sanity (mature Astro integration, real-time editing, gets expensive), Storyblok (visual editing strong, $99/mo+), and UnfoldCMS (one-time license, full Laravel CMS that you can decouple — official headless API on the roadmap). Contentful works but is overpriced for typical Astro use. Strapi and Payload work but require more setup. Hygraph fits if you're GraphQL-only.

Quick Comparison: 7 CMS Options for Astro

What Makes a CMS Actually Work With Astro

The Astro–CMS interface has four moving parts that determine real-world DX. Get any of them wrong and the partnership breaks down.

1. Build-time vs runtime fetching. Astro defaults to static output — content gets fetched at build time and burned into HTML. Your CMS needs a fast API that doesn't choke when 200 pages all await fetch() during the same build. Rate-limited APIs (Sanity free tier, Contentful starter) become bottlenecks fast. CMSes with no rate limits (UnfoldCMS, self-hosted Strapi/Payload) avoid this entirely.

2. Content collections compatibility. Astro 5's content layer is the modern way to type content. Your CMS needs to expose JSON the loader can consume directly, with stable schemas. Sanity, UnfoldCMS, and Storyblok all work cleanly here. WordPress headless gets messy because plugin field types don't map to TypeScript predictably.

3. Image optimization. Astro's <Image /> component expects local files OR remote URLs with consistent loaders. CMSes with built-in image pipelines (Sanity, Storyblok) integrate via Astro's image service config. Self-hosted CMSes typically need Cloudflare Images or imgproxy in front to get parity.

4. Live preview and on-demand revalidation. Astro added experimental on-demand rendering and a live preview API in v5. Your CMS needs to fire webhooks when content changes and your Astro deploy needs to rebuild affected pages or use server-island rendering. Sanity Live Preview and Storyblok Visual Editor are the gold standard here. Self-hosted CMSes need you to wire it manually — typically a 10-line endpoint.

If a CMS doesn't handle these four cleanly, you'll spend the first month of any project building plumbing instead of features.

The Honest Shortlist

Out of the seven options in the table above, three are realistic for most Astro teams. The rest are situational.

1. UnfoldCMS — Best for Agencies and Content Sites

Pricing: $39 (Core), $99 (Pro), $349 (Business, 5 sites), $799 (Agency, unlimited). One-time. No usage metering, no per-seat pricing, no per-environment fees.

Stack: Laravel 12 + MySQL. Admin is built on shadcn/ui — 50 components, 183 admin pages, Tailwind v4, three switchable themes. See also: production CMS built on shadcn/ui.

Astro DX (today): UnfoldCMS is currently a full Laravel CMS — it ships its own themed frontend, not a public headless API. Using it as a content backend for Astro today means writing a small Laravel route in your CMS that returns JSON (5 lines), then fetching that route inside src/content/config.ts or directly in .astro files. Build-time fetching works fine.

What's coming: A first-class headless mode is on the roadmap — official public REST + GraphQL endpoints for posts, pages, and settings; signed webhooks on content changes; draft preview tokens; and an official @unfoldcms/astro integration. Until that ships, treat UnfoldCMS as a "Laravel CMS you can decouple" rather than a turnkey headless source.

Where it wins for Astro: One-time pricing, no API metering means preview builds and CI runs don't burn budget. Includes a themed frontend if you need a marketing-site fallback alongside Astro. Built-in SEO records, redirects, comments, and forms.

Where it loses today: No turnkey public API yet — you write your own thin Laravel routes for the data you need. No real-time multi-cursor editing. No hosted CDN out of the box (pair with Cloudflare). Smaller community than Sanity or Strapi.

Pick if: You're an agency running multiple Astro client sites, a SaaS founder building marketing pages, or a team that wants predictable one-time pricing instead of monthly bills that scale with traffic.

See UnfoldCMS pricing → | Live demo →

2. Sanity — Best for Design-Led Teams

Pricing: Free tier (3 users, 10k documents). Growth at $99/month per project. API requests are metered — overages bill at $1 per 100k requests. Astro builds with 100+ pages can hit 1–3M API requests/month easily, especially with preview branches.

Stack: Hosted document store + customizable React Studio. GROQ query language (Sanity-specific), with GraphQL also available. Studio is open-source and self-hostable; the document store is managed.

Astro DX: Excellent. The official @sanity/astro integration handles client setup, draft mode, and Visual Editing out of the box. The live API streams real-time content into Astro server islands.

Where it wins: Real-time collaborative editing (live cursors, presence). Visual editing inside the live Astro page (click any text element, edit it in Sanity). Mature image pipeline with hotspots and on-the-fly transforms.

Where it loses: Pricing scales fast. Per-project model — agencies running 10 Astro sites pay 10× $99/month. GROQ has a learning curve unique to Sanity. We covered the cost reality in UnfoldCMS vs Sanity.

Pick if: Multiple editors collaborate on the same documents in real-time as a daily workflow, you're a design-led team where the editorial UI is part of the product, or you have budget for $200–$2,000/month in CMS infrastructure.

3. Storyblok — Best for Marketing Teams That Live in Visual Editing

Pricing: Free for solo (1 user, 1 environment). Plus at $99/month. Business at $499/month. Per-environment limits matter — staging counts as a separate environment on most plans.

Stack: Hosted content + visual editor. REST and GraphQL APIs. Components are configured as "blocks" — non-technical editors drag-drop them into pages.

Astro DX: Excellent. The official @storyblok/astro integration handles preview mode, live editing, and component bridging. You map Storyblok blocks to Astro components in a single config file, and the visual editor renders your real Astro components inside the editor.

Where it wins: Best-in-class visual editor. Marketing teams can build pages without touching code. Strong i18n features. Mature ecosystem.

Where it loses: Visual-first model is overkill for sites with structured content (docs, blog posts). API rate limits can bite on big builds. Per-environment pricing makes preview deploys expensive. Smaller dev community than Sanity.

Pick if: Your editors live in WYSIWYG and refuse to touch markdown, you're building a marketing site where landing-page composition is the primary workflow, or you need strong i18n out of the box.

The Situational Options

These four aren't wrong for Astro — they're just narrower fits.

Contentful: Mature, polished, expensive. Starts at $300/month per space and scales to $5,000+/month. Pick only if you're a large enterprise that already has the budget approved. For most Astro teams, the pricing math doesn't work.

Strapi: OSS Node CMS. Strapi v5's REST API works fine with Astro. Pick if you want OSS-first and prefer Strapi's plugin philosophy. We covered the trade-offs in UnfoldCMS vs Strapi.

Payload: TypeScript-native, self-hosted Node CMS. Works with Astro via standard REST, but Payload's strength is end-to-end TypeScript inside a Next.js project — less of an advantage when your frontend is Astro. See UnfoldCMS vs Payload CMS for trade-offs.

Hygraph: GraphQL-only, fast, well-typed. Starts at $79/month. Pick if your team is GraphQL-native and you want zero REST. Decent Astro DX via standard GraphQL clients.

Decision Framework

Pick by team and project shape — not by feature count.

Choose UnfoldCMS for Astro if:

• You're building marketing sites, blogs, or content properties (not custom apps with bespoke editorial workflows)
• You want one-time pricing instead of monthly bills that scale with traffic and projects
• You're OK writing a small Laravel route to expose the data you need today (a turnkey headless API is coming, not shipped yet)
• Your team is OK running PHP alongside your Astro Vercel/Netlify deploy

Choose Sanity if:

• Multiple editors collaborate on the same document in real time, daily
• Visual editing inside the live Astro site is a hard requirement
• Budget is approved for $200–$2,000/month in CMS spend

Choose Storyblok if:

• Editors must build pages visually, never touch code
• Marketing-led page composition is the primary editorial workflow
• Per-environment pricing fits your team size

For everything else, the situational options above might fit — but for most teams shipping an Astro content site in 2026, the realistic choice is between these three.

Astro + UnfoldCMS: How It Works Today

Honest version: UnfoldCMS today is a full Laravel CMS. It does not yet ship a public headless API for blog posts and pages. To use it with Astro, you write a small Laravel route in your CMS that returns JSON, then fetch that route from Astro's content layer.

This is more work than @sanity/astro or @storyblok/astro. It's also more flexible — you decide exactly which fields are public, no SDK lock-in, no rate-limit gotchas. For a typical content site, it's a one-hour setup.

1. Add a public route in your Laravel CMS

In routes/web.php of your UnfoldCMS install:

Route::get('/public/posts', function () {
    return \App\Models\BlogPost::where('is_published', true)
        ->get(['slug', 'title', 'body_html as body', 'posted_at']);
});

Five lines. Pick whichever fields your Astro site needs.

2. Fetch from a content collection

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

const blog = defineCollection({
  loader: async () => {
    const res = await fetch(`${import.meta.env.UNFOLD_API_URL}/public/posts`);
    const posts = await res.json();
    return posts.map((post: any) => ({ id: post.slug, ...post }));
  },
  schema: z.object({
    title: z.string(),
    body: z.string(),
    posted_at: z.string(),
  }),
});

export const collections = { blog };

3. Render a post page

---
// src/pages/blog/[slug].astro
import { getCollection } from 'astro:content';
import Layout from '../../layouts/Layout.astro';

export async function getStaticPaths() {
  const posts = await getCollection('blog');
  return posts.map((post) => ({
    params: { slug: post.id },
    props: { post },
  }));
}

const { post } = Astro.props;
---

<Layout title={post.data.title}>
  <article>
    <h1>{post.data.title}</h1>
    <div set:html={post.data.body} />
  </article>
</Layout>

Standard Astro patterns. No SDK, no auth dance.

What's coming

Headless mode is on the roadmap and will replace the manual route step:

• Public, versioned REST + GraphQL endpoints for posts, pages, settings, and media
• Signed webhooks on content events (publish, update, delete) — wireable to Vercel/Netlify deploy hooks for rebuilds
• Draft preview tokens with a one-click "Preview in Astro" button in the admin
• Official @unfoldcms/astro integration with typed content collections

Until those ship, the manual-route pattern above is the supported way to use UnfoldCMS with Astro.

Performance: Why Astro + Self-Hosted CMS Is Hard to Beat

Astro's whole architecture punishes managed CMS overpricing.

Astro generates static HTML at build time. A user request to /blog/[slug] hits Vercel's edge and serves pure HTML — your CMS API is never called for visitor requests. The only times your CMS gets hit:

1. During astro build — fetches all content once, caches it
2. When a webhook fires a rebuild — usually once per content change

So the "global CDN" Sanity or Contentful charges for is duplicative. Your Astro deploy already serves at the edge. The CDN matters for media assets (images, video) — and there, Cloudflare Images at $5/month handles 99% of cases.

For UnfoldCMS specifically: your Astro Vercel deploy serves all visitor traffic. Your $5/month UnfoldCMS host serves the API maybe a few hundred times per day during builds. The architecture is fundamentally cheaper than paying $99–$300/month for a hosted CMS.

This isn't theoretical — it's how content sites built on Astro typically work. Self-hosted CMS + edge static + Cloudflare for images. Hosting bill: under $20/month total.

Trust Block

Who this is for: Astro developers shipping content sites, marketing pages, or blogs who want a CMS that hits Astro's static-first sweet spot without per-seat fees, API metering, or Node-only deployment.

What it replaces: Sanity, Contentful, Storyblok, Strapi, or building a custom Astro Content Collections workflow that breaks every time a non-developer wants to add a post.

What it costs: $39 one-time (Core, 1 domain) up to $799 (Agency, unlimited domains). No monthly fees, no API request limits.

What happens after you buy:

1. Install UnfoldCMS on any PHP 8.3 host — under 5 minutes
2. Write a small Laravel route to expose your content as JSON for Astro to fetch at build time
3. Run astro build as usual — content fetches once at build, ships as static HTML

FAQ

What's the best free CMS for Astro? For pure OSS, Strapi (community edition) and Payload (MIT-licensed) are the two strongest options. Both are self-hosted and work cleanly with Astro's content collections via REST APIs. Strapi has a wider plugin ecosystem; Payload has stronger TypeScript ergonomics.

Which CMS works best with Astro 5 content collections? Any CMS that exposes a stable JSON API works — including UnfoldCMS, Sanity, Storyblok, and Strapi. Custom loaders in src/content/config.ts let you fetch and shape the data however you want. The CMS just needs to be fast (build-time fetching) and predictable (stable schemas).

Is Astro better than Next.js for content sites? For content-heavy sites with minimal interactivity, yes. Astro's "zero JS by default" and Islands architecture produce faster pages with less complexity than equivalent Next.js sites. For app-like products with heavy client interactivity, Next.js is usually the better fit. We covered Next.js specifically in Best CMS for Next.js.

How do I do preview mode in Astro with a headless CMS? Enable hybrid or server output mode in astro.config.mjs. Issue a draft token from your CMS, set a cookie when the editor clicks "Preview", and gate your fetch URL on that cookie. Sanity and Storyblok support this out of the box. UnfoldCMS does not ship draft preview tokens today — it's on the roadmap. For now you can wire your own toggle in a custom Laravel route.

What's the cheapest CMS for an Astro site? A one-time UnfoldCMS license at $39 plus $5/month shared hosting is the cheapest production-grade option. Strapi self-hosted is free if you operate the Node infrastructure yourself; Sanity's free tier works for hobby projects but caps at 3 users and 10k documents.

Can I migrate from WordPress to Astro + UnfoldCMS? Yes. WordPress exports XML; UnfoldCMS imports posts via REST API. Map content fields, import, switch your DNS — done. We have a migration guide here and a Migration Service starting at $149 if you want it done for you.

Does UnfoldCMS support GraphQL for Astro? Not officially yet. Today you expose data via a small Laravel JSON route (REST). A first-class GraphQL endpoint is on the roadmap alongside the public REST API and Astro integration.

Will my Astro site be slower with a self-hosted CMS than a managed one? For static-output Astro sites, no — visitors never hit the CMS. The CMS is only called during builds. The "global CDN" of managed CMSes is duplicative because your Astro deploy already serves at the edge.

Methodology

Pricing data is from each vendor's public pricing page as of May 2026. Stack and feature evaluations reference official Astro documentation, each CMS's developer docs, and direct integration testing on production Astro 5 projects. Quotes and community sentiment are sourced from r/astro, r/webdev, and Hacker News public discussions. Performance claims about Astro + edge caching reflect Vercel/Netlify's published architecture and our own production deployments.

Try UnfoldCMS for Your Astro Project

If UnfoldCMS sounds like the right fit, the live demo takes about 90 seconds — browse the admin, create a post, see how the API responds. Pricing is one-time and all tiers include the full source. The Core tier at $39 lets you test the full product on a real Astro project.

For more comparisons specific to your evaluation, see UnfoldCMS vs Sanity, vs Payload, vs Contentful, or vs Strapi. Each one digs into the trade-offs honestly — including where the competitor wins.

If a different CMS in this list fits your project better, that's a fine answer too. The point of this page is to give you the information to decide, not to pretend UnfoldCMS is the answer to every Astro project.

Related: UnfoldCMS vs Storyblok, migrate from WordPress, or browse all CMS comparison guides.