Headless CMS

A complete headless CMS. Live preview included.

Model content with Pages, Entries, and Blocks. Deliver it over a one-fetch REST API with a typed client. And let editors preview everything live, without you standing up a preview environment.

Content modeling

Structure first. Presentation second.

Every field is typed, every reference is explicit. Your API mirrors exactly what you modeled - nothing more, nothing less.

Routable

Pages

Static pages with fixed paths (/about, /contact) and collections with automatic slug-based routing (/blog/[slug]).

Shared

Entries

Non-routable structured content - authors, settings, menus, categories. Referenced inline by pages and other entries. Single and collection variants both supported.

Composable

Blocks

Reusable components: hero, features grid, testimonials, pricing tables. Type-checked fields control what editors configure. Change a block once and it propagates everywhere.

Field types
Text
Rich Text
Paragraph
Markdown
Number
Boolean
Date / Time
Dropdown
Link
Color
Code
JSON
Image
File / Document
Entry Reference
Dynamic Blocks (Stack)
Collection
Location
A stack field in action
hero Care that feels personal
features 3-column benefits grid
testimonials Patient stories carousel
cta Book a visit

Editors reorder, add, and remove blocks - each one type-checked against its model.

Composable pages

The Stack field: pages editors assemble themselves.

Declare one stack field and editors compose pages from your block library - hero, features, testimonials, CTA - in any order, without touching a developer.

Every block keeps its typed fields, so no one can break the design: the structure is guaranteed by the model, the arrangement is up to the editor.

Content delivery

One fetch. Entire content graph.

No N+1 queries, no resolver trees, no waterfalls. A single request returns everything your frontend needs - environment-scoped and instantly cacheable.

API response shape

KeyContents
pagesAll routable content - each with _path, _slug, and all field data
entriesKeyed by handle - single objects or arrays
imagesNamed site-level images, accessible by key
optionsOption sets as [{ label, value }] arrays
configSite title, origin URL
_tagChanges on every publish - use for cache invalidation
import { createSyncClient } from '@sleekcms/client';

const client = await createSyncClient({
  siteToken: process.env.SLEEKCMS_SITE_TOKEN,
});

// Fetches all content upfront - then reads are instant
const home  = client.getPage('/');
const posts = client.getPages('/blog', { collection: true });
import { createAsyncClient } from '@sleekcms/client';

const client = createAsyncClient({
  siteToken: process.env.SLEEKCMS_SITE_TOKEN,
});

// Fetches on demand - fresh content per request
const page = await client.getPage('/services');
import { usePage } from '@sleekcms/react';

function Post({ slug }) {
  const { page, loading, error } = usePage(`/blog/${slug}`);
  if (loading) return <Skeleton />;
  return <article><h1>{page.title}</h1></article>;
}

Full TypeScript types on every method. npm install @sleekcms/client and go.

Environments

Publish like you deploy.

Content is environment-scoped: point local dev at the latest draft state, keep production pinned to a published snapshot, and promote when ready. Nothing changes on the live site until you publish.

latest Always the current content - for dev and preview
staging A named alias pointing to a published snapshot
production What your live site reads - stable until you publish
The headless-CMS missing piece

Live preview, no preview app.

With most headless CMSes, "preview" means building and hosting a second frontend. SleekCMS ships with a site builder - so editors see real, rendered pages on every save, before anything is published.

Editors preview every change on real pages
No preview deployment to build or maintain
API consumers still get clean JSON
Use the builder, the API, or both - same models

Model once. Deliver anywhere.

Free forever plan. Full platform. No credit card required.