The headless CMS that
works like your codebase.
Define content models in code. Sync them with one command. Generate type-safe clients automatically. Let AI handle the content creation so your team ships faster.
Schema-as-Code
Your content model lives in your repo.
Define content models in .laizy files using a clean, readable syntax inspired by Prisma. Your schema is version-controlled, diff-friendly, and the single source of truth for your content structure.
No more clicking through admin panels to add a field. No more wondering if staging matches production. Your schema is code — it goes through code review, gets deployed with your app, and rolls back when you do.
- Git-trackable — review schema changes in PRs
- Readable syntax — anyone on the team can understand the content model
- Constraint validation — required, unique, maxLength, defaults
model BlogPost {
title: String {
required: true
maxLength: 200
}
content: Markdown {
required: true
}
slug: String {
required: true
unique: true
}
author: Author
tags: BlogTag[]
publishedAt: DateTime
}$ laizy init
✓ Created ~/.laizyrc
✓ Created laizy/schema.laizy
✓ Linked to project "my-website"
$ laizy sync
✓ Analyzing schema changes...
+ BlogPost (6 fields)
+ Author (3 fields)
✓ 2 models synced
$ laizy generate
✓ Generated types.ts
✓ Generated client.ts
✓ TypeScript client ready
$ laizy content create BlogPost
✓ Created BlogPost (ec87a7ei)
$ laizy content list BlogPost --status published
ID Title Status
ec87a7ei Hello World publishedCLI-First Workflow
Five commands. That's the entire workflow.
Initialize, define your schema, sync to the database, generate a typed client, create content. Every operation is a CLI command — no clicking through admin panels, no context switching.
Because everything is a command, everything is scriptable. Hook it into your CI pipeline, run it from a cron job, or hand it to an AI agent. The CLI is the universal interface.
laizy sync— schema diffing with impact analysis and dry-run modelaizy generate— instant TypeScript client with full type safetylaizy content— create, list, and manage content from the terminal
AI Content Creation
Your team chats. Content ships.
Non-technical team members create content through natural conversation. No training, no documentation, no “where do I click?” moments. They describe what they want. The AI understands your schema and creates structured, valid content.
Content creators don't need to know about field types, validation rules, or publishing workflows. They just talk about the content they want to create — the AI handles the structure.
- Schema-aware — AI knows your content models and validates against constraints
- AI-generated hero images with one-click generation
- Schedule, tag, and publish — all from the conversation
Introducing Our New API Features
We're excited to announce three major additions to the Laizy API: token-based auth, real-time webhooks, and batch operations...
Multi-Tenant Architecture
One account. Unlimited projects.
Every project is fully isolated — its own schemas, content, tokens, and access controls. Switch between clients in the CLI with laizy link or manage them all from the dashboard. Share projects across organizations with role-based access.
import { LaizyClient } from './generated/laizy'
// Full autocomplete on every model
const posts = await client.blogPost.findMany()
// TypeScript knows the shape of your data
posts.forEach((post) => {
console.log(post.title) // string
console.log(post.slug) // string
console.log(post.content) // string
})
// Single item by ID — also fully typed
const post = await client.blogPost.findById('abc123')Type-Safe Clients
Generated types. Zero guesswork.
Run laizy generate and get a TypeScript client that knows the exact shape of your content. Every model, every field, every method — fully typed with autocomplete in your editor.
Change your schema? Regenerate and TypeScript will tell you everywhere your code needs updating. No runtime surprises. No “undefined is not an object” in production.
- Prisma-like API —
findMany(),findById(),count() - Full autocomplete — your editor knows every field
- Compile-time safety — catch content model changes before they ship
Agent-Ready Automation
Your content runs itself.
Because Laizy is fully programmatic — schema-as-code, CLI, REST API — it's trivially easy to build automations. We provide agent skill packs for Claude Code, Cursor, and Windsurf so AI agents can manage your entire content pipeline without leaving the terminal.
Imagine: a weekly digest agent that reads your product updates, writes a blog post, generates a hero image, and publishes it — all while you sleep. That's not a demo. That's Tuesday.
- Agent skill packs for Claude Code, Cursor, and Windsurf
- CLI + API — every operation is automatable
- From trigger to published in seconds, not hours
$ laizy agent run weekly-digest
⏳ Analyzing recent product updates...
✓ Found 3 updates since last digest
⏳ Generating blog post...
✓ Created "Product Updates: Week of Feb 10"
⏳ Generating hero image...
✓ Generated hero-image.jpg
⏳ Publishing...
✓ Published BlogPost (a8c7e2f91b)
→ https://acme.com/blog/product-updates-feb-10
📊 Weekly digest complete
Posts created: 1
Status: published
Duration: 12sAnd more
Everything else you'd expect.
Live Preview
See changes before they ship
Edit content in the dashboard and preview it in real-time on your actual site. No deploy cycles, no branch switching.
REST API
Standard HTTP, zero lock-in
Every content operation is a standard REST endpoint. Use the generated client or call the API directly — your choice.
AI Image Generation
Hero images on demand
Generate on-brand images directly from the content editor. Powered by Black Forest Labs and OpenAI with custom style profiles.
Webhooks
React to content changes
Get notified when content is created, updated, or published. Build workflows, invalidate caches, or trigger deployments.
Content Scheduling
Publish on your timeline
Schedule content to publish at a specific time. Works from the dashboard, CLI, or AI chat.
Audit Logs
Know who changed what
Every content change is tracked with timestamps, user info, and before/after snapshots. Full accountability for teams.
Ship your first content model
in under five minutes.
One command to install. One file to define your schema. Instant type-safe client generation.