Start Zero-1.
Describe what data your frontend needs.

Or wire Zero-1 into your AI agent via MCP — the agent gets every operation as a callable tool.

{
  "mcpServers": {
    "z1": {
      "command": "bun",
      "args": ["run", "/path/to/z1/mcp.ts"]
    }
  }
}

It's a real API.
Curl it.

Every resource you describe becomes a live endpoint with full CRUD — GET, POST, PUT, PATCH, DELETE. IDs are auto-assigned. FK references are always valid. Data is generated from field names, not random garbage.

Filtering, sorting, text search, and pagination are all described in natural language when you set up a scenario — the query behaviour follows from how you described the data. The query API reflects exactly what you asked for.

Works with whatever
you're already using.

Zero-1 is plain HTTP — point your data layer at localhost:7777 and it works. No SDK, no adapter, no wrapper. Swap the base URL when your real backend is ready.

// Swap BASE when your real backend is ready
const BASE = 'http://localhost:7777';

// Fetch a list
const posts = await fetch(`${BASE}/posts?sort=likes:desc&limit=10`)
  .then(r => r.json());

// Create a record
const created = await fetch(`${BASE}/posts`, {
  method:  'POST',
  headers: { 'Content-Type': 'application/json' },
  body:    JSON.stringify({ userId: 1, title: 'Hello', likes: 0 }),
}).then(r => r.json());

// Delete
await fetch(`${BASE}/posts/42`, { method: 'DELETE' });

import { useState, useEffect } from 'react';

const BASE = 'http://localhost:7777';

export default function PostList() {
  const [posts,   setPosts]   = useState([]);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetch(`${BASE}/posts?sort=likes:desc`)
      .then(r    => r.json())
      .then(data => { setPosts(data); setLoading(false); });
  }, []);

  if (loading) return <p>Loading…</p>;
  return posts.map(p => (
    <div key={p.id}>{p.title}</div>
  ));
}

import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';

const BASE = 'http://localhost:7777';

export default function PostList() {
  const qc = useQueryClient();

  const { data: posts = [], isLoading } = useQuery({
    queryKey: ['posts'],
    queryFn:  () => fetch(`${BASE}/posts?sort=likes:desc`).then(r => r.json()),
  });

  const create = useMutation({
    mutationFn: (body) => fetch(`${BASE}/posts`, {
      method:  'POST',
      headers: { 'Content-Type': 'application/json' },
      body:    JSON.stringify(body),
    }).then(r => r.json()),
    onSuccess: () => qc.invalidateQueries({ queryKey: ['posts'] }),
  });
}

<script setup>
import { ref, onMounted } from 'vue';

const BASE  = 'http://localhost:7777';
const posts = ref([]);

onMounted(async () => {
  posts.value = await fetch(`${BASE}/posts?sort=likes:desc`)
    .then(r => r.json());
});

async function create(payload) {
  const post = await fetch(`${BASE}/posts`, {
    method:  'POST',
    headers: { 'Content-Type': 'application/json' },
    body:    JSON.stringify(payload),
  }).then(r => r.json());
  posts.value.unshift(post);
}
</script>

import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

const BASE = 'http://localhost:7777';

@Injectable({ providedIn: 'root' })
export class PostsService {
  constructor(private http: HttpClient) {}

  list(): Observable<Post[]> {
    return this.http.get<Post[]>(`${BASE}/posts?sort=likes:desc`);
  }

  create(body: Partial<Post>): Observable<Post> {
    return this.http.post<Post>(`${BASE}/posts`, body);
  }
}

Data that reacts.
Not just sits there.

Endpoints can react to each other. Describe the side-effect logic inline in your scenario — create an order and stock decrements, post a comment and the count increments, delete a user and their content is removed. Zero-1 wires it so your mock API behaves like the real thing.

Change the schema
while it's running.

Describe what changed. Zero-1 sends only the schema to Claude (not the data), applies the diff, and backfills all existing records locally — O(records) time, flat ~1024-token API call regardless of dataset size.

Added fields get context-aware generated values — views gets realistic view counts, email gets real-looking addresses. Unknown fields fall back to type-appropriate random values.

Want pagination?

Describe what you need — cursor, offset, or page-based — in plain English. Every response field name is under your control. Zero-1 configures the envelope so it matches whatever your real API will produce.

Need a header guard
on a route?

Describe the rule — bearer token, API key, custom header. Zero-1 enforces it. Your frontend gets real 401s to handle. Guards can also inject response headers on every matching request, so you can simulate X-Request-Id, WWW-Authenticate, rate limit headers — whatever your real API sends back.

JWT claims.
Isolate records by user.

Map a JWT claim to a resource field and Zero-1 enforces per-user record isolation automatically. No middleware to write — pass a Bearer token, get back only the records that belong to you.

Inline the parent.
Expand any FK field.

Add ?expand=field to any GET request and Zero-1 replaces the FK value with the full parent record. Multiple fields, comma-separated. No N+1 — all resolved in one pass.

Expansion uses the live knowledge graph to resolve FK edges. If the FK target resource doesn't exist or the referenced ID is not found, the field is left as-is.

Upload a file.
Get a real URL back.

POST multipart form data to any resource endpoint. Zero-1 stores the bytes in memory, replaces the file field with a /__uploads/{id} URL, and serves the original bytes with the correct Content-Type when fetched.

File bytes live in memory alongside all other Zero-1 state. They are included in fork snapshots and global export/import. Uploads are served at GET /__uploads/:id with the original Content-Type and filename.

Full OAuth 2.0 provider,
from a description.

Describe the flow. Zero-1 runs a real OAuth 2.0 / OIDC provider locally — auth code, PKCE, client credentials, scopes, refresh tokens, introspection, OIDC discovery. No JWT library, no crypto package. Token signing via Web Crypto API (HS256).

Registered: /authorize · /token · /revoke · /introspect · /userinfo · /.well-known/openid-configuration · /.well-known/jwks.json. Per-client scope enforcement included.

Make it fail
on purpose.

Inject failures, latency, and rate limits into any endpoint. Describe the chaos inline in your scenario, or add it on top of a live API. Rules are additive — latency stacks, error rates evaluate independently. Chaos never affects /__generate/* meta endpoints.

Build your API
directly in Cursor.

Zero-1 ships a zero-config MCP server. Add it to Cursor, VS Code, or any MCP-compatible editor and create endpoints, inject chaos, fork workspaces — all from the chat panel, without leaving your editor.

{
  "mcpServers": {
    "z1": {
      "command": "bun",
      "args": ["run", "/path/to/z1/mcp.ts"]
    }
  }
}

Fork the state.
Wreck it safely.

Clone the entire running state into an isolated workspace. Route requests with X-Workspace and only that fork mutates.

See how everything
connects.

Zero-1 maintains a live knowledge graph of every resource, foreign-key edge, and denormalized field copy it has observed. Zero config — it builds itself from traffic. Open the visual explorer or query the JSON API.

Open /__generate/graph-view for an interactive D3 force graph — click any node or edge for details, drag to rearrange, live auto-refresh every 3 seconds.

Import a spec.
Export your state.

Point Zero-1 at an existing OpenAPI or Swagger spec and it imports the resources directly. Export your current state as JSON to share with a teammate or restore later.

What are you building?

Type what your project actually needs. These are examples.