documentation

Everything you need to build with C for CMS.

Get started, model your content, and integrate the REST and GraphQL APIs into any stack.

Getting Started

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.
Getting Started

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:

First request
curl 'https://api.cforcms.com/api/v1/my-project/blog-posts?limit=10' \
  -H 'X-API-Key: sk_live_a1b2c3d4e5f6'
note

Keep secret keys (sk_live_…) on the server. Never ship them in client-side bundles.

Getting Started

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.

Authenticated 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.

note

Studio sessions use JWT with optional Google OAuth. API keys are the recommended path for applications.

Content

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

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

Filter, sort, populate
GET /api/v1/my-project/blog-posts
  ?filter[status]=published
  &sort=-publishedAt
  &limit=10
  &populate=author

Responses are paginated with a meta block containing page, limit, total, and totalPages.

Content

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.

APIs

REST API

Every content type is exposed as a REST resource with consistent query parameters for filtering, sorting, pagination, and population.

Base URL

Endpoint
https://api.cforcms.com/api/v1/{project}/{contentType}

Response shape

Response
{
  "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.

APIs

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
query GetPosts($locale: String) {
  blogPosts(
    filter: { status: { eq: "published" } }
    sort: "-publishedAt"
    limit: 10
    locale: $locale
  ) {
    id
    title
    slug
    publishedAt
    author { name avatar }
  }
}
APIs

Webhooks

Subscribe to content events and react in real time. Deliveries are HMAC-signed, retried with exponential backoff, and fully logged.

Payload

entry.published
{
  "event": "entry.published",
  "timestamp": "2025-03-15T10:00:00Z",
  "project": "my-project",
  "contentType": "blog-posts",
  "entry": { "id": "post_8x9kL2", "status": "published" }
}

Verifying signatures

HMAC verification
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),
  );
}
Platform

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.

Platform

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.
note

AI runs on a swappable provider — bring Anthropic Claude or Google Gemini depending on your preference.

Platform

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.

Start Building