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.
Structure first. Presentation second.
Every field is typed, every reference is explicit. Your API mirrors exactly what you modeled - nothing more, nothing less.
Pages
Static pages with fixed paths (/about, /contact) and collections with automatic slug-based routing (/blog/[slug]).
Entries
Non-routable structured content - authors, settings, menus, categories. Referenced inline by pages and other entries. Single and collection variants both supported.
Blocks
Reusable components: hero, features grid, testimonials, pricing tables. Type-checked fields control what editors configure. Change a block once and it propagates everywhere.
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.
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.
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
| Key | Contents |
|---|---|
| pages | All routable content - each with _path, _slug, and all field data |
| entries | Keyed by handle - single objects or arrays |
| images | Named site-level images, accessible by key |
| options | Option sets as [{ label, value }] arrays |
| config | Site title, origin URL |
| _tag | Changes 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.
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
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.
Related features & comparisons
Static Site Generator
Skip the frontend project entirely - render the same models with built-in EJS views.
Learn moreSleekCMS vs Contentful
An honest look at where each platform wins for structured content teams.
Learn moreSleekCMS vs Sanity
Real-time collaboration vs zero-maintenance delivery - matched to your scenario.
Learn moreModel once. Deliver anywhere.
Free forever plan. Full platform. No credit card required.