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, REST + GraphQL, content collections-friendly). 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 + REST API + GraphQL. Self-hosted on any PHP 8.3 host. The admin is built on shadcn/ui — 50 components, 183 admin pages, Tailwind v4, three switchable themes.

Astro DX: Standard fetch() to REST endpoints inside your src/content/config.ts loader or directly in .astro files. Build-time fetching just works. Webhook → rebuild trigger is a 12-line Vercel/Netlify hook. Image URLs are predictable; pair with Cloudflare Images for free CDN delivery. Content collections integration via a custom loader takes about 20 lines.

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. Built-in SEO records, redirects, comments, and forms — features other CMSes outsource to plugins.

Where it loses: No real-time multi-cursor editing (Sanity wins there). No hosted CDN out of the box (you set up 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 want a CMS that ships a themed frontend so you can launch faster (or just use Astro and the REST API)
• 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 Actually Works

Here's the integration in practice — from npx create astro to live content in about 30 minutes.

1. 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}/api/blog/posts`);
    const { data } = await res.json();
    return data.map((post: any) => ({
      id: post.slug,
      ...post,
    }));
  },
  schema: z.object({
    title: z.string(),
    body: z.string(),
    posted_at: z.string(),
    seo_title: z.string().nullable(),
    meta_desc: z.string().nullable(),
  }),
});

export const collections = { blog };

That's the read path. Astro's content layer caches results during build, so 200 pages don't hammer the API.

2. Render a post page

---
// src/pages/blog/[slug].astro
import { getCollection, getEntry } 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.seo_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, no rate-limit retries.

3. Webhook → rebuild

UnfoldCMS fires a webhook when posts are updated. Wire it to your Vercel/Netlify deploy hook:

// src/pages/api/revalidate.ts (Astro endpoints, on-demand rendering)
import type { APIRoute } from 'astro';

export const POST: APIRoute = async ({ request }) => {
  const secret = request.headers.get('x-unfold-webhook-secret');
  if (secret !== import.meta.env.UNFOLD_WEBHOOK_SECRET) {
    return new Response('unauthorized', { status: 401 });
  }

  // Trigger a Vercel/Netlify rebuild
  await fetch(import.meta.env.DEPLOY_HOOK_URL, { method: 'POST' });
  return new Response(JSON.stringify({ ok: true }), { status: 200 });
};

10 lines, no plugin needed. Set the webhook URL in UnfoldCMS admin → Settings → Webhooks.

4. Live preview (optional)

For draft preview during editing, enable Astro's hybrid output mode and gate draft content behind a cookie:

---
const isDraft = Astro.cookies.has('preview');
const url = `${import.meta.env.UNFOLD_API_URL}/api/blog/posts/${slug}${isDraft ? '?preview=1' : ''}`;
const post = await fetch(url).then(r => r.json());
---

Editors click "Preview" in the UnfoldCMS admin, get redirected to your Astro site with the cookie set, and see the unpublished content.

That's the entire Astro + UnfoldCMS integration. Three files, no plugins, no monthly metering.

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.

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, UnfoldCMS, and Storyblok all support this; Contentful needs slightly more wiring.

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? Yes. UnfoldCMS exposes both REST and GraphQL endpoints. Use whichever your team prefers; REST is recommended for Astro content collections since the JSON shape maps directly to Zod schemas without a GraphQL client.

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. See also: Best CMS for SvelteKit.