Everything you need to build with C for CMS.
Get started, model your content, and integrate the REST and GraphQL APIs into any stack.
Introduction
C for CMS is an API-first headless CMS. Model your content, and get production-ready REST and GraphQL APIs instantly — no backend to write or maintain.
You design content types in the visual Studio, and C for CMS generates the storage, validation, and delivery APIs for you. Your frontend — web, mobile, or anything that speaks HTTP — reads and writes through a single, consistent interface.
How it works
- Model — define content types with 17 field types in the Studio.
- Create — author entries with drafts, publishing, and localization.
- Deliver — query over REST or GraphQL from any client.
Core concepts
- Organization — the top-level tenant that owns projects and billing.
- Project — an isolated content space with its own schema, entries, media, and API keys.
- Content type — the schema definition for a kind of content (e.g. blog-posts).
- Entry — a single record of a content type.
Quick Start
Create a project, define your first content type, add an entry, and query it over the API — in about five minutes.
1. Create a project
Sign in to the Studio, create an organization, and add a project. Each project gets an isolated schema and its own set of API keys.
2. Define a content type
In the Studio, create a content type called blog-posts with a title (Text), body (Rich Text), and status (Select). Save to publish the schema — your APIs update instantly.
3. Query the API
Generate an API key with content:read scope, then fetch your entries:
curl 'https://api.cforcms.com/api/v1/my-project/blog-posts?limit=10' \
-H 'X-API-Key: sk_live_a1b2c3d4e5f6'Keep secret keys (sk_live_…) on the server. Never ship them in client-side bundles.
Authentication
C for CMS supports project-scoped API keys for server-to-server access, plus JWT and Google OAuth for Studio users.
API keys
API keys are scoped to a single project and carry a set of permission scopes. Pass the key in the X-API-Key header on every request.
curl 'https://api.cforcms.com/api/v1/my-project/blog-posts' \
-H 'X-API-Key: sk_live_a1b2c3d4e5f6' \
-H 'Content-Type: application/json'Scopes
Grant each key only what it needs: content:read, content:write, media:read, media:write, schema:read, schema:write, webhook:read, webhook:write, team:read, team:write.
Studio sessions use JWT with optional Google OAuth. API keys are the recommended path for applications.
Content Types
Content types are your schemas. Compose them from 17 field types to model anything from a blog post to a product catalog.
Field types
- Text, Textarea, Rich Text, Number, Boolean, Date, DateTime
- Email, URL, JSON, Select, Multi-select
- Media, Media List, Relation, Repeater, Component
Relations & components
Use Relation fields to link entries across content types, Repeater fields for ordered lists of nested data, and Component fields for reusable groups of fields shared between types.
Content Entries
Entries are individual records. Every content type gets full CRUD endpoints with filtering, sorting, pagination, search, and relation population.
Draft & publish
Entries move through a draft → published lifecycle. The API returns published entries by default; request drafts explicitly with a content:write key.
Querying
GET /api/v1/my-project/blog-posts
?filter[status]=published
&sort=-publishedAt
&limit=10
&populate=authorResponses are paginated with a meta block containing page, limit, total, and totalPages.
Media
Upload and organize files in a Cloudflare R2-backed media library with folders, automatic thumbnails, and presigned delivery URLs.
Uploads
Upload files via the Studio or the media API. Images get thumbnails generated automatically, and everything is searchable by type and folder.
Delivery
Attach media to entries with Media and Media List fields. Files are served through presigned URLs so you keep control over access.
REST API
Every content type is exposed as a REST resource with consistent query parameters for filtering, sorting, pagination, and population.
Base URL
https://api.cforcms.com/api/v1/{project}/{contentType}Response shape
{
"data": [ /* entries */ ],
"meta": { "page": 1, "limit": 10, "total": 42, "totalPages": 5 }
}Add format=csv to any list request to export results as CSV instead of JSON.
GraphQL
Prefer GraphQL? Every project exposes an auto-generated schema so you can request exactly the fields you need in one round trip.
Example query
query GetPosts($locale: String) {
blogPosts(
filter: { status: { eq: "published" } }
sort: "-publishedAt"
limit: 10
locale: $locale
) {
id
title
slug
publishedAt
author { name avatar }
}
}Webhooks
Subscribe to content events and react in real time. Deliveries are HMAC-signed, retried with exponential backoff, and fully logged.
Payload
{
"event": "entry.published",
"timestamp": "2025-03-15T10:00:00Z",
"project": "my-project",
"contentType": "blog-posts",
"entry": { "id": "post_8x9kL2", "status": "published" }
}Verifying signatures
import crypto from 'crypto';
function verifyWebhook(payload: string, signature: string, secret: string) {
const expected = crypto
.createHmac('sha256', secret)
.update(payload)
.digest('hex');
return crypto.timingSafeEqual(
Buffer.from(signature),
Buffer.from(expected),
);
}Organizations & Teams
C for CMS is multi-tenant by design. Organizations own projects, and roles control access at every level.
Roles
- Organization — owner, admin, member.
- Project — admin, editor, viewer.
Invite team members to an organization and assign per-project roles so each person sees exactly what they should.
AI Features
Built-in AI helps you model faster and write better — generate content types from a prompt and run per-field actions on your copy.
Capabilities
- Generate a content type from a natural-language description.
- Per-field actions: generate, improve, translate, summarize.
- SEO suggestions for titles, descriptions, and slugs.
AI runs on a swappable provider — bring Anthropic Claude or Google Gemini depending on your preference.
Self-Hosting
Run C for CMS on your own infrastructure. Ships as Docker Compose with Kubernetes manifests included.
The stack
- NestJS API server
- PostgreSQL with Prisma ORM
- Redis for caching and queues
- Cloudflare R2 (or any S3-compatible store) for media
Bring up the full stack with Docker Compose, or deploy the included manifests to your Kubernetes cluster for full control over your data.
Ready to build?
Spin up a free project and make your first API call in minutes.