Best CMS for Remix (and React Router v7) in 2026

Remix put data fetching in one place: the route loader. Your CMS call lives server-side in that loader, the data streams to the component, and you never ship a content API key to the browser. That's a cleaner content model than most frameworks — and it shapes which CMS actually fits.

There's a wrinkle in 2026: Remix folded into React Router v7. If you're on Remix v2 or the newer React Router v7 framework mode, the loader pattern is the same, so this guide covers both. What matters for your CMS choice isn't the framework name — it's that content is fetched in a server loader, cached there, and rendered on the server.

Here's an honest picker for seven CMS options that fit Remix / React Router v7 in 2026, sorted by editor experience, hosting, and price. Every one works with the loader pattern. The differences are who edits the content, whether you self-host, and what it costs.

TL;DR — the fast picks

• Best editor DX for a content team → Sanity
• Enterprise governance and environments → Contentful
• Open source, self-hosted, plugin ecosystem → Strapi
• Self-hosted, modern admin, paid once → UnfoldCMS
• Markdown in your repo, no backend → MDX / flat-file
• GraphQL-native hosted → Hygraph
• Expose an existing SQL database → Directus

The Remix loader pattern decides everything

In Remix / React Router v7, you fetch content in a route loader that runs on the server:

// app/routes/blog.$slug.tsx
export async function loader({ params }: LoaderFunctionArgs) {
  const res = await fetch(`https://your-cms.com/api/v1/posts/${params.slug}`)
  return json(await res.json())
}

Because the fetch is server-side, three things follow:

1. API keys stay on the server — you never expose a content token to the browser. Any CMS with a plain REST/GraphQL API fits.
2. Caching is yours to control — you cache in the loader (HTTP headers, Cache-Control, or a server cache), not in a client SDK. CMSes that are "just an API" fit this better than ones that assume a heavy client library.
3. You render on the server — so runtime API latency matters. A fast, paginated CMS API keeps your loaders quick.

The upshot: Remix rewards CMSes with simple, fast, server-consumable APIs. Fancy client SDKs and visual-editing overlays matter less here than they do in a client-heavy framework.

1. Sanity — best authoring experience

Best for: teams with dedicated editors producing lots of structured content.

Sanity's Studio is the nicest place to write in this list — real-time collaboration, structured content, and GROQ for precise queries. In a Remix loader you call Sanity's HTTP API (or its client) and get exactly the fields you asked for. For an editor-heavy team, the authoring DX is worth the SaaS bill.

It's hosted and usage-priced (API requests, seats, bandwidth). Great at small scale, climbs as you grow. If editor happiness is your priority, Sanity leads.

2. Contentful — enterprise and governance

Best for: larger orgs that need roles, staging environments, and localization.

Contentful brings content environments (staging vs prod), granular permissions, and a mature ecosystem. Its REST and GraphQL APIs drop straight into a Remix loader. It's the safe enterprise pick when governance outweighs cost.

The downside is price — the most expensive tier here past the free plan — and more machinery than a small team needs.

3. Strapi — open source, self-hosted

Best for: teams that want to own the backend and avoid per-seat pricing.

Strapi is the go-to open-source headless CMS. Self-host the Node app, build your content types, and hit its REST or GraphQL API from your Remix loader. No SaaS bill, full data ownership, a real plugin ecosystem. The cost is operational: you run and upgrade the Node service and its database yourself.

4. UnfoldCMS — self-hosted, modern admin, one-time price

Best for: teams that want a polished self-hosted CMS without a recurring bill or a Node backend to maintain.

UnfoldCMS is a PHP/Laravel CMS with a React + shadcn/ui admin. From a Remix loader it's just an API: fetch() its REST endpoints at /api/v1/* — posts, pages, categories, search, menus — server-side, exactly where the loader pattern wants the call. There are no official npm SDKs; you call the JSON directly, which suits Remix's "fetch in the loader" model perfectly.

export async function loader() {
  const posts = await fetch('https://your-cms.com/api/v1/posts').then(r => r.json())
  return json(posts)
}

The pricing is the pitch: a one-time license, self-hosted, no monthly fee. And HMAC-signed outgoing webhooks mean that if you pre-render parts of your Remix app, a publish can trigger a rebuild automatically.

Honest limits: PHP 8.3+ backend (not Node), no content revisions, no multi-language content (template UI strings only). If you need per-locale content or an approval chain, look elsewhere.

5. MDX / flat-file — no backend at all

Best for: developer-run sites where content is Markdown in the repo.

You don't always need a CMS. For a docs site or a developer blog, keep content as MDX/Markdown files in your Remix repo and read them in the loader with a small utility (or a library like mdx-bundler). Content is versioned in Git, deploys with the app, costs nothing, and adds zero runtime dependency.

The limit: no editor UI. Non-technical people can't publish without touching Git. If every author is a developer, this is the simplest and cheapest option. If not, use a real CMS above.

6 & 7. Hygraph and Directus — the runners-up

Hygraph (formerly GraphCMS) is a hosted, GraphQL-native headless CMS. If your Remix app already speaks GraphQL, its API fits naturally in a loader. Usage-based pricing.

Directus wraps any SQL database in an instant REST + GraphQL API plus a clean admin. Self-host (open source) or use their cloud. Best when you want to expose an existing database to Remix with minimal glue code.

Remix / React Router v7 CMS comparison — 2026

Which should you pick for Remix?

• Editor team that lives in the CMS → Sanity.
• Enterprise with governance needs → Contentful.
• You run infra and want open source → Strapi.
• You want a modern self-hosted admin and no recurring bill → UnfoldCMS. Its plain-REST API is a natural fit for loaders.
• Content is Markdown and you're all developers → MDX/flat-file. Don't add a CMS you don't need.

FAQ

Does Remix work the same as React Router v7 for a CMS?

Yes, for content purposes. Remix v2's loader and React Router v7 framework mode's loader share the same server-side data-fetching model. Your CMS call lives in the loader either way, so any CMS in this list works across both. The framework rename doesn't change the integration.

Where should I put the CMS fetch in Remix?

In the route loader, server-side. That keeps your CMS API key off the client, lets you control caching with response headers, and renders content on the server. Don't fetch content from the browser unless you specifically need client-side updates.

Can I use a PHP CMS with Remix?

Yes. Remix only consumes an API — it doesn't care what language the CMS runs on. UnfoldCMS is PHP/Laravel and exposes a REST API at /api/v1/* that you fetch() inside a loader. No SDK required; the JSON endpoints are the whole interface.

Do I need an SDK to connect a CMS to Remix?

No. The loader pattern is built around fetch, so a plain REST or GraphQL call is all you need. Some CMSes offer SDKs for convenience, but UnfoldCMS ships no official SDK — you call its endpoints directly, which is usually less code inside a loader than wiring up a client.

How do I cache CMS data in a Remix loader?

Return Cache-Control headers from the loader (or the route's headers export) so the CDN/edge caches the response. For self-hosted CMSes you can also cache server-side. This keeps runtime API calls off the critical path for repeat visitors.

Deciding between a full CMS and building your own admin? Our UnfoldCMS vs Strapi comparison covers self-hosted trade-offs, or check the pricing if the one-time model fits.