Best CMS for SolidJS in 2026 (Headless, REST & GraphQL)

SolidJS gives you React-like components with fine-grained reactivity and no virtual DOM — signals update exactly the DOM nodes that changed, nothing more. It's fast, it's small, and it's a genuinely nice way to build a UI. What it doesn't give you is a place to put your content. There's no official "SolidJS CMS," and honestly, there doesn't need to be.

Any headless CMS with an HTTP API works with SolidJS, because SolidJS talks to content the same way it talks to any other data: a fetch() call wrapped in a resource. This post covers how to wire a CMS into a SolidJS app, which CMS options fit best, and the one thing that actually matters when you pick one.

Building with SolidStart (the SSR meta-framework) instead of plain SolidJS? The rendering model changes — server functions and streaming SSR vs client-side fetch. See Best CMS for SolidStart for that setup. This post is about SolidJS as a client-rendered library.

TL;DR — the short version

• SolidJS has no framework-specific CMS, and doesn't need one. Any headless CMS with a REST or GraphQL API works.
• Content loads through createResource — SolidJS's built-in async primitive. Fetch JSON, render it, done.
• Pick a CMS by API quality and hosting model, not by "SolidJS support" — nobody has special Solid support and none is needed.
• Best self-hosted pick: UnfoldCMS — clean REST at /api/v1/*, flat cost, you own the data.
• Best if you want GraphQL: Strapi or Directus, both self-hostable.

Why SolidJS doesn't need a special CMS

Here's the thing nobody says out loud: "CMS for framework X" is mostly a marketing category. A headless CMS is just a JSON API. SolidJS is just a UI library that renders JSON. The connection between them is fetch(), which is the same in Solid, React, Vue, or vanilla JavaScript.

What SolidJS does have is a clean async primitive built for exactly this. createResource takes a fetcher function, tracks its loading and error state, and re-runs when its source signal changes. You don't need a data-fetching library. You don't need special CMS bindings. You need a URL that returns JSON.

So the real question isn't "which CMS supports SolidJS" — it's "which CMS has a good API and a hosting model I like." Those are different questions, and the second one actually matters.

How to load CMS content in SolidJS

Here's a working example that pulls posts from a headless CMS into a SolidJS component. This uses UnfoldCMS's REST API, but the shape is identical for any REST CMS — swap the URL.

import { createResource, For } from "solid-js";

const fetchPosts = async () => {
  const res = await fetch("https://your-cms.com/api/v1/posts");
  const json = await res.json();
  return json.data; // array of posts
};

function BlogList() {
  const [posts] = createResource(fetchPosts);

  return (
    <ul>
      <For each={posts()}>
        {(post) => (
          <li>
            <a href={`/blog/${post.slug}`}>{post.title}</a>
          </li>
        )}
      </For>
    </ul>
  );
}

That's the whole integration. createResource handles loading and error state; <For> renders the list with SolidJS's keyed reactivity. To load a single post, pass the slug as a source signal so the resource re-fetches when the route changes:

const [post] = createResource(
  () => params.slug,
  (slug) => fetch(`https://your-cms.com/api/v1/posts/${slug}`).then((r) => r.json())
);

No CMS-specific SDK. No framework adapter. Just the Fetch API and SolidJS's own primitives.

What to actually look for in a CMS for SolidJS

Since "SolidJS support" is a non-issue, judge a CMS on the things that change your day-to-day:

1. API clarity — is the JSON predictable? Paginated cleanly? Documented?
2. Rebuild hooks — if you pre-render pages, can the CMS ping your build on publish?
3. Hosting and cost — SaaS with usage-based billing, or self-hosted with a flat cost?
4. Editor experience — can non-developers add content without touching code?
5. Data ownership — can you export everything and move if you need to?

The best CMS options for SolidJS in 2026

UnfoldCMS — best self-hosted REST option

UnfoldCMS is a self-hosted CMS built on Laravel 12 and React 19. For a SolidJS front end, what matters is its API: a versioned REST surface at /api/v1/* with paginated posts, pages, categories, search, and menus — all returning predictable JSON envelopes that drop straight into createResource.

Two things make it a strong Solid pairing. First, cost is flat — you host it, so a traffic spike doesn't spike a bill. Second, outgoing HMAC-signed webhooks fire on publish, so if you pre-render your SolidJS routes as static pages, the CMS can trigger your host's rebuild the moment content changes. It requires PHP 8.3 on the host, and it's REST, not GraphQL — worth knowing if your team prefers queries.

Pick it if: you want a modern admin, a clean REST API, and predictable cost.

Strapi — best open-source, GraphQL-capable option

Strapi is the most popular open-source headless CMS. It ships REST by default and has an official GraphQL plugin, so your SolidJS app can query content however you prefer. It's self-hostable (free) or available as Strapi Cloud.

The trade-off is ops: self-hosting means you own upgrades, plugins, and scaling. For a SolidJS team already comfortable running a Node backend, that's familiar territory.

Pick it if: you want open-source, a big community, and the option of GraphQL.

Directus — best if you have a database already

Directus wraps an existing SQL database and exposes it over REST and GraphQL. If your SolidJS app already has a Postgres or MySQL backend, Directus turns it into a content API without a new content model. Self-hostable, so cost stays flat.

Pick it if: you want your existing database exposed as a clean API for SolidJS to consume.

Contentful or Sanity — best managed SaaS options

If you'd rather not run a server, Contentful and Sanity are mature managed CMSs with solid REST/GraphQL APIs and generous free tiers. SolidJS consumes them the same way — fetch plus createResource. The cost climbs with usage, which is the usual SaaS trade-off, but you skip all the hosting work.

Pick it if: you want zero infrastructure and will accept usage-based pricing.

CMS options for SolidJS compared

Server-render or client-render?

Plain SolidJS ships a client-rendered SPA — the browser fetches content after load. That's fine for dashboards and app-like sites, but for content you want indexed by search engines, client-only rendering costs you SEO because crawlers may not run your JavaScript.

Two ways to fix it:

• Static pre-render at build time — generate HTML for each post ahead of time, and use the CMS's publish webhook to rebuild when content changes. Best for blogs and marketing sites.
• Move to SolidStart — the SolidJS meta-framework adds server-side rendering and server functions, so content is rendered on the server per request. If SEO matters and your content changes often, this is the cleaner path. See Best CMS for SolidStart.

For an app where SEO doesn't matter — an internal tool, a dashboard, a logged-in experience — plain client-side SolidJS with createResource is all you need.

FAQ

Is there a CMS built specifically for SolidJS?

No, and you don't need one. SolidJS loads content through the Fetch API and createResource, so any headless CMS with a REST or GraphQL API works without special bindings. "CMS for SolidJS" is a use case, not a product category.

How do I fetch CMS content in SolidJS?

Use createResource. Pass it a fetcher function that calls your CMS API and returns the JSON. SolidJS tracks loading and error state automatically and re-runs the fetch when its source signal (like a route param) changes. No data-fetching library required.

What's the best free CMS for a SolidJS project?

Strapi and Directus are free and open-source — you only pay for the server they run on. Both offer REST and GraphQL. If you want a managed free tier with no hosting, Contentful and Sanity both have one.

Does SolidJS work with a self-hosted CMS?

Yes. SolidJS doesn't care where the API lives — it just needs a URL that returns JSON. Self-hosted options like UnfoldCMS, Strapi, and Directus work identically to SaaS CMSs from SolidJS's side, and give you flat cost plus full data ownership.

Should I use SolidJS or SolidStart for a content site?

Use SolidStart if SEO matters — its server-side rendering makes content crawlable out of the box. Use plain SolidJS for apps and dashboards where content loads client-side and SEO isn't a concern. The CMS integration is nearly identical either way.

The bottom line

SolidJS doesn't need a special CMS — it needs a good API and createResource. Pick your CMS on the things that actually differ: hosting model, cost, and API quality. If you want to own your data with predictable cost, UnfoldCMS gives you a clean REST API and a modern admin. Want GraphQL? Strapi or Directus. Want zero ops? Contentful or Sanity. Then wrap the fetch in a resource and get back to building the fast little UI SolidJS is so good at.

See the features page, check the API docs, or try the demo to see the content API in action.