Rebase

The Open-Source Backend-as-a-Service for Postgres — with the Admin Panel that comes with it

Point it at a database and get a working backend in minutes.
REST, auth, storage, realtime and backups over your own Postgres — then add a schema-driven admin panel, or don't.
Own your data, own your code. The absolute easiest way to build on PostgreSQL.

Public beta. The API you write against can change in a minor, with a changelog entry. Your data cannot break quietly.
What that promise rests on, and which subsystems are ready

Live Demo • Documentation • Features • Discord

What is Rebase?

Rebase is a developer-first, open-source backend-as-a-service built on PostgreSQL — authentication, S3-compatible storage, realtime, backups and auto-generated REST APIs over a database you own. It is self-hosted and agent-native, with a built-in MCP server for AI-assisted development.

The admin panel is the second layer of the same definition: add collection definitions and you get a schema-driven back-office built from them, extensible with your own React components, serverless functions, and scripts.

Adopt only what you want

Three modes, same packages, wired differently — see MODULAR-ARCHITECTURE.md.

✨ Key Highlights

• 🔓 No Vendor Lock-in — Self-host anywhere. Full control over your infrastructure, code, and database.
• 🧱 Modular — Start as a pure API and add the admin panel later, or never. Nothing is bundled that you didn't ask for.
• ⚡ Instant Setup — pnpm dlx @rebasepro/cli init scaffolds a complete project in seconds.
• 🗄️ PostgreSQL First — First-class Postgres support with Drizzle ORM, schema introspection, and automatic migrations.
• 🔒 Secure by Default — Authorization is Postgres RLS, not application code. Tables without row-level security aren't served.
• 🧩 Radical Extensibility — Not constrained to pre-built widgets. If you can build it in React, you can build it in Rebase.
• 🎨 Premium UI — Fast, accessible design system built on Tailwind CSS v4 and Radix UI.
• 🤖 AI-Ready — MCP server for AI-assisted database management, plus data enhancement and insights plugins.

⚡ Quick Start

Scaffold a complete, self-hosted Rebase application connected to your database:

pnpm dlx @rebasepro/cli init my-rebase-app
cd my-rebase-app
pnpm install
pnpm run dev

That is the whole first run — no database to install, no schema step. With no DATABASE_URL set, rebase dev starts a managed PostgreSQL (PGlite) that lives in the project directory, generates the schema from your collections, and creates the tables at boot.

Read the URLs from its output. rebase dev picks a free port per project rather than fixed ones, so they differ between projects. PORT and VITE_API_URL in .env apply to rebase start, not here.

Useful flags: --yes (required when there is no terminal to prompt, such as CI), --headless (see below), --template <name>, and --install / --no-install on init; --docker on dev to use the compose Postgres in this project instead, and --no-db to start nothing — set DATABASE_URL yourself.

To use your own Postgres instead: uncomment DATABASE_URL in .env and run pnpm run dev again. Nothing else changes — a DATABASE_URL that is set is never touched, and one pointing anywhere other than this machine is left alone entirely.

Just want the API?

Rebase is modular — take only the parts you want:

pnpm dlx @rebasepro/cli init my-api --headless

That scaffolds a headless backend: REST, auth, storage, realtime and backups over your database, with no collection files and no UI. Tables are served automatically, derived from your schema at boot — change the schema with a migration and the API follows. No React anywhere in the dependency tree.

A fresh headless project has no tables yet, so /api/data/* answers 404 NO_COLLECTIONS until you create some. Point it at a database that already has tables, or add them with a migration, and they appear.

The three adoption modes — BaaS (like Supabase), CMS (like Payload/Directus), and both together — are described in MODULAR-ARCHITECTURE.md.

Features

🏓 Full Admin Panel & CMS

An incredibly fast, windowed spreadsheet view to manage your database with inline editing, real-time updates, filtering, sorting, and text search. Switch between multiple view modes:

• Spreadsheet table — Inline editing, column reordering, drag-and-drop
• Card grid — Visual overview with image previews
• List view — Compact, scannable layout
• Kanban board — Cards grouped into columns by a property, dragged between them
• Custom views — Build any React component as a collection view

🔒 Typed Schema & Database Migrations

Define your data models using pure TypeScript collections. Rebase automatically generates your Drizzle ORM schema, handles PostgreSQL migrations, and keeps your live database perfectly in sync using built-in tooling like rebase doctor.

💾 Backups & Restore

First-class database backups for self-hosted Postgres, built on pg_dump / pg_restore:

• rebase db backup --out <path|s3://…> — compressed, custom-format dumps
• rebase db restore <backup> — confirmation-gated, with --create-db / --target-db to restore into a fresh database
• Scheduled backups via the built-in cron system, uploading to your configured storage backend with retention pruning
• Studio Backups panel — browse and download backups from the admin UI

See Backups and restore for the full guide — including what a backup does not cover (your uploaded files), security and PITR notes.

🔐 Authentication & Access Control

Built-in authentication with multiple providers:

• Email/Password — With password reset flow
• OAuth — Google, Apple, GitHub, GitLab, Bitbucket, Microsoft, Facebook, LinkedIn, Discord, Slack, Spotify and X
• Magic link and one-time codes — Passwordless sign-in by email
• MFA — TOTP second factor with recovery codes
• Anonymous — For guest access, opt-in
• Captcha and API keys — Bot protection on sign-up and the routes that send mail; scoped keys for scripts and agents

Granular role-based access control (RBAC) with customizable permissions per collection, field, and action.

📦 S3-Compatible Storage

Native S3-compatible file storage with:

• Drag-and-drop uploads with progress tracking
• Automatic image resizing and optimization
• File metadata management
• Storage browser in Studio

🛠️ Studio — Developer Toolbox

A full developer environment built into the admin panel — SQL and JS editors, RLS policies, a schema visualizer, database branches, backups, request logs, cron jobs, a storage browser, an API explorer and API keys. What each tool does →

🔌 Realtime Engine

A full WebSocket engine built into every Rebase backend:

• Live data subscriptions — Subscribe to collection queries or individual entities. Changes propagate instantly with RLS-aware security.
• Broadcast channels — Send typed messages between connected clients. Build chat, notifications, or collaborative features.
• Presence tracking — Track who's online, sync user state across clients (typing indicators, cursor positions, online status).
• Auto-reconnect — Exponential backoff, automatic resubscription, and token refresh on reconnect.

📴 Offline & Local-First Sync

Opt in with offline: true and the client SDK keeps a local database of rows instead of a cache of responses:

• Reads survive a dropped connection — filters, sorting and pagination are evaluated against the local rows, so lists keep rendering.
• Writes apply instantly — a write made offline lands locally, queues, and replays in order when the connection returns. One the server rejects is rolled back.
• Live queries — observe() emits from the local database before any request, and re-emits on local writes, replays, rollbacks, realtime events, and changes from other tabs.

⚡ Extensible API & Edge Functions

Drop custom Hono routes or scheduled tasks into the functions/ and crons/ directories. Rebase auto-loads them with database access and JWT authentication middleware injected automatically.

🧬 SDK Generator

Auto-generate fully typed TypeScript SDKs from your collection definitions. Use them in any frontend, script, or service to interact with your Rebase backend with complete type safety.

pnpm dlx @rebasepro/cli generate-sdk

🤖 MCP Server

A built-in Model Context Protocol server that enables AI assistants to:

• Query and manage your database schema
• Create, read, update, and delete documents
• Manage users and roles
• Introspect your data model

🔍 Schema Inference & Introspection

Point Rebase at an existing PostgreSQL database and automatically generate collection definitions from your tables — including types, relations, validation constraints, and more.

📥📤 Import & Export

Import data from CSV, JSON, and Excel with an intuitive field mapper. Export your data in multiple formats with configurable column selection.

🧩 Plugins

Extend the admin experience with first-party plugins:

• Data Enhancement — AI-powered field suggestions and auto-fill
• Insights — Analytics dashboards and usage metrics

📜 Standalone Scripting

Write standalone data manipulation scripts that connect directly to your running backend using the @rebasepro/client SDK. The CLI persists the dev server URL to .rebase-dev-url for zero-config local development.

🧩 Custom Views & React Extensibility

Build entirely custom views — dashboards, previews, charts — and drop them into the main navigation or as entity-level tabs. Use built-in hooks to interact with Rebase's internal state.

🛠️ Core Technologies

Built entirely on modern, battle-tested web standards:

📦 Packages

Rebase is structured as a modular monorepo — install only the layers you need:

ESM only

Every @rebasepro/* package ships ES modules and nothing else — "type": "module", no CommonJS build, no require() entry point. A CommonJS project reaches them with a dynamic await import(); require("@rebasepro/client") throws ERR_REQUIRE_ESM. This is stated here because the failure names the loader rather than the decision, and because it is not recoverable by configuration: there is no dual build to fall back to.

Node 22.22 is the floor, from .nvmrc and enforced by pnpm check:floors.

Versioning

Rebase is 0.x: the authored TypeScript API can still change in a minor, and every such change is in the changelog.

Separately, a small set of contracts is versioned and enforced — the bundle format, the bundle↔runtime contract, the auth schema version, and the hash identifying which collection schema a generated SDK was built against. These are stamped into built artifacts and live databases, checked at boot, and fail with a specific message rather than degrading. They are also the only things Rebase Cloud depends on, which is what lets a project move between self-hosting and the cloud. See docs/compatibility.md.

🎨 Standalone UI Library

Rebase exposes its design system as a completely independent library. Fully typed, accessible, and customizable via Tailwind CSS v4:

pnpm add @rebasepro/ui

Demo

Explore a live interactive sandbox with all features — data resets periodically:

👉 demo.rebase.pro

🤖 AI Coding Assistants & Agent Support

Rebase is designed from the ground up to be AI-agent ready. When developing a Rebase project using AI coding assistants (like Cursor, Windsurf, or Copilot):

1. Built-in Agent Guidelines (ai-instructions.md)

Every project scaffolded with rebase init carries its agent rules in ai-instructions.md, plus a short pointer file for each assistant that reads its own — AGENTS.md, CLAUDE.md, .cursorrules, .windsurfrules and .github/copilot-instructions.md. Each pointer names ai-instructions.md and the rebase skills install --agent <name> command for that assistant. The rules cover:

• Using the Rebase SDK instead of raw SQL / direct Drizzle queries against application tables (which skip validation, hooks and row-level security).
• Applying a collection change: while pnpm dev runs, saving the collection file is the whole step; db:push is for what boot leaves alone, and production uses db:generate then db:migrate.
• Guarding custom functions, and what an agent must never do — deploy, edit .env, or hand-edit generated files.

2. Built-in MCP Server

rebase init writes .mcp.json, so Claude Code, Cursor and any other MCP client can drive the project the moment it is scaffolded:

{
  "mcpServers": {
    "rebase": {
      "command": "npx",
      "args": ["-y", "@rebasepro/mcp"],
      "env": {
        "REBASE_PROJECT_DIR": "."
      }
    }
  }
}

It speaks MCP over stdio and needs no login: while rebase dev is running it reads the backend URL and service key from .rebase/state.json. Write tools are refused against anything that is not on the loopback interface, which is the single most valuable thing in the package.

Setup, the tool list, and what the server can reach → — copy-paste blocks for Claude Code, Cursor, Gemini CLI, Codex and Kiro, and the credential model to read before pointing an assistant at a database you care about.

3. Troubleshooting Database Permissions in Studio

If your AI coding agent or database role permissions cause a permission denied for table <table_name> error when executing queries in the Rebase Studio SQL Editor:

• Add DISABLE_DB_ROLE_SWITCHING=true to your .env file.
• This forces the SQL Editor queries to execute under the default connection owner user (e.g. rebase) rather than trying to perform a PostgreSQL role switch to a non-existent database-level role.

Contributing

Bug fixes, features and documentation are all welcome. CONTRIBUTING.md is the whole path: clone, install, start the database, run the app, and the one command — pnpm ci:static — that runs what CI runs. It also covers commits and the changelog rule, and how to run one package's tests.

Two more worth knowing before a first pull request:

• .agent/workflows/coding-standards.md — the engineering rules this codebase is held to, and the reasons behind them. No as any, no dynamic require, no polling on a realtime framework, no hidden dunder properties on data objects. Written for an AI agent, and exactly as binding on a person.
• docs/gates.md — every automated check, what it protects, and how to bank its baseline when it has one.

Who builds Rebase?

Built and maintained by Camberi, a product engineering studio in Madrid and Munich that also builds for clients.

Support & Community

• 📖 Documentation
• 💬 Discord Community
• 🐛 GitHub Issues
• 📝 Changelog

⭐ Star Us

If you find Rebase useful, please consider giving us a star on GitHub — it helps more developers discover the project!

License

Rebase is open-source and licensed under the MIT License. See the full License for details.