Integrations

Works with everything you already use.

Laizy connects to your existing stack through typed clients, a CLI your agents can drive, and a REST API that works from anywhere. No adapters, no middleware layers, no vendor SDKs to learn.

Core Integrations

Native support where it matters.

Deep integrations with the frameworks and tools that power modern web development. Not wrappers around a generic API — purpose-built for each platform.

Next.js

Built for the App Router from day one. Fetch content in Server Components with zero client-side JavaScript. The generated Laizy client works natively with async components, ISR, streaming, and the full Next.js data layer. Your content queries are typed, cached, and co-located with the components that render them.

app/blog/page.tsx
import { LaizyClient } from '@/generated/laizy'
import { ManagementClient } from '@/lib/management-client'

const client = new LaizyClient(
  new ManagementClient({
    baseUrl: process.env.LAIZY_URL,
    apiToken: process.env.LAIZY_TOKEN,
  })
)

export default async function BlogPage() {
  const posts = await client.blogPost.findMany()

  return (
    <ul>
      {posts.map((post) => (
        <li key={post.id}>{post.title}</li>
      ))}
    </ul>
  )
}
Next.js integration guide

React

First-class React support with typed hooks and components. Use the Laizy client in React Server Components for zero-bundle-cost data fetching, or import it into client components when you need interactivity. Works with React 19, Suspense boundaries, and the latest concurrent features out of the box.

components/blog-list.tsx
import { LaizyClient } from '@/generated/laizy'
import { use } from 'react'

// React 19: unwrap promises with use()
export function BlogList({
  postsPromise,
}: {
  postsPromise: Promise<BlogPost[]>
}) {
  const posts = use(postsPromise)

  return posts.map((post) => (
    <article key={post.id}>
      <h2>{post.title}</h2>
    </article>
  ))
}
React integration guide

Claude Code / AI Agents

Your AI agent already knows how to use Laizy. The schema lives in your repo as a readable file the agent can inspect. The CLI is a set of composable commands the agent can execute. And the output is structured JSON the agent can parse. No custom tooling, no MCP servers, no prompt engineering required — the entire content pipeline is automatable from the terminal.

Terminal
> Set up Laizy CMS for this project with a blog

$ laizy init
✓ Linked to project "my-site"

$ # Agent reads laizy/schema.laizy, adds BlogPost model

$ laizy sync
✓ 1 model synced (BlogPost, 4 fields)

$ laizy generate
✓ TypeScript client ready

$ # Agent imports client, builds the blog page
✓ Created app/blog/page.tsx with typed queries
Agent workflow docs

REST API

Clean, typed REST endpoints for every operation. Full CRUD on all content models, filtering by status, pagination with offset and limit, and consistent JSON responses. Authenticate with a bearer token and start querying. Works from any language, any platform, any environment — if it can make an HTTP request, it can talk to Laizy.

Terminal
$ curl -H "Authorization: Bearer laizy_sk_..." \
  https://api.laizycms.com/v1/content/BlogPost

{
  "data": [
    {
      "id": "ec87a7ei",
      "title": "Introducing Laizy CMS",
      "slug": "introducing-laizy-cms",
      "status": "published"
    }
  ],
  "total": 1
}
API reference

Developer Tools

Fits into the workflow you have.

Laizy is designed around the tools and patterns you already use. No new paradigms to learn, no vendor-specific concepts to internalize.

TypeScript

First-class types generated directly from your schema. Every content model, every field, every method — typed and autocomplete-ready. Change the schema, regenerate, and TypeScript tells you what needs updating.

CLI

Manage your entire content pipeline from the terminal. Initialize projects, sync schemas, generate clients, create content, and check status — all composable commands that work in scripts, CI, and agent workflows.

Git

Schema files live in your repo alongside your code. Review content model changes in pull requests, track them in commit history, and deploy them with your app. Your content structure is version-controlled by default.

Vercel

Zero-config deployment on Vercel. Set your LAIZY_URL and LAIZY_TOKEN environment variables and your content is available at build time and runtime. Works with ISR, on-demand revalidation, and edge functions.

Prisma

If you know Prisma, you know Laizy. The schema syntax is familiar, the CLI workflow is similar, and the generated client uses the same patterns — findMany(), findById(), count(). Transfer your existing muscle memory.

Resend

Email notifications and webhooks built in. Get notified when content is published, scheduled, or updated. Build automated email workflows triggered by content events without writing integration code.

On the Roadmap

More frameworks, more platforms.

We are building native integrations for additional frameworks and platforms. In the meantime, the REST API works everywhere — these integrations will add framework-specific conveniences on top.

Vue

Coming Soon

Svelte

Coming Soon

Astro

Coming Soon

Shopify

Coming Soon

WordPress Import

Coming Soon

Don't see your framework?

The REST API covers every operation Laizy supports. If your framework can make HTTP requests and parse JSON, you can integrate it today. For framework-specific features or custom integration needs, reach out and we will work with you.

Request an IntegrationExplore the API

Ship your first content model in under five minutes.

One command to install. One file to define your schema. Instant type-safe client generation.

$pnpm create laizy@latest
Start Building