Documentation

• FAQ: Frequently asked questions about Jazz.
• Overview: The database that syncs.
• Quickstart: Scaffold a synced local-first app in one command.
• Authentication: How and when to use Jazz's auth modes, and how to manage JWT auth over the lifetime of a live client.
• Lifecycle: Client auth lifecycle: local-first identity storage, sign-in and sign-out, storage reset, and upgrading to external auth.
• Local-first auth: Authenticate users without a server using self-signed tokens, and optionally upgrade to an external provider while preserving identity.
• Permissions: Jazz's approach to row-level security using relationship-based access controls, and how to build policies of varying complexity.
• Sessions: Reading the current session and scoping queries and inserts to the logged-in user.
• Branches: How Jazz uses branches to isolate data across environments, schema versions, and user-defined contexts.
• How Sync Works: An overview of how Jazz syncs data between clients, covering query subscriptions, infrastructure tiers, offline behavior, and eventual consistency.
• Local-First Data Model: An overview of how Jazz manages local state, row histories, conflicts, and loading behavior.
• Client Setup: Set up Jazz in your app — works out of the box with most frameworks, with manual configuration available when needed.
• Server Setup: Hosted and self-hosted database server configuration, app provisioning, and backend context setup.
• Client: Build a local-first to-do app with Jazz, step by step.
• TypeScript Server: Build a server-side to-do API with Jazz and Hono, step by step.
• Filters, Sorting & Pagination: Filter rows with where(), sort with orderBy(), and paginate with limit/offset.
• Includes & Relations: Resolve references with include(), pick columns with select(), inspect permissions, and run recursive queries.
• Queries: One-shot queries, subscriptions, framework hooks, Suspense integration, and read durability options.
• Durability Tiers: API reference for read and write durability tiers: the options that control how far data must propagate before an operation confirms.
• Examples: What each example app in the Jazz monorepo uniquely demonstrates.
• Framework Patterns: Side-by-side reference for React/Expo, Vue, and Svelte Jazz APIs.
• Inspector: Standalone admin client for exploring Jazz sync servers, schemas, permissions, and live queries.
• Advanced Internals: How Jazz works under the hood: raw tables, row histories, sync, the query pipeline, and the browser architecture.
• Local-first auth internals: How local-first auth derives a stable account from a secret, how the self-signed JWT is structured, and how the server verifies it without an external key store.
• MCP Server: Give your AI assistant direct access to Jazz documentation via the Model Context Protocol.
• WHERE Operators: Full reference for filter operators available in Jazz query builders, with examples for each column kind.
• Column Types: Every column type available in the TypeScript DSL and its SQL equivalent.
• Defining Tables: Define tables and relationships in schema.ts using the TypeScript DSL.
• Migrations: Structural schema evolution workflow and reviewed migration edges.
• Files & Blobs: Chunked browser Blob and stream storage using conventional files and file_parts tables.
• Writing Data: Insert, update, and delete APIs with local-first execution, framework context hooks, and an intro to durability tiers.
• Group permissions: Model a workspace with role-based access control using a members table and existence-based permissions.
• Shared access between users: Grant other users access to your data using a shares table and existence-based permissions.
• User-owned data: End-to-end walkthrough of the most common Jazz pattern: data that belongs to the user who created it.
• Auth provider integration: Connect an external auth provider to Jazz with JWT validation, with examples for Better Auth and WorkOS.
• Better Auth Adapter: Use Better Auth with Jazz as the database adapter.
• Nested data with permission inheritance: Model a project/task/comment hierarchy with inherited permissions, queries, and multi-level inserts.
• Real-time collaborative list: Multiple users subscribing to the same data and seeing each other's changes in real-time.