One backend for your app.
Most backends stop at a database and sign-in. Scribase gives you the whole app backend: database, sign-in, push, store subscriptions, over-the-air updates, crash reports and deep links. One account, one command. Idle projects scale to zero and wake on the next request.
1 project free with no time limit, no card. More projects from $5 a project a month.
No card. Or let your agent do it:npx scribase init
Next.js, Expo, SvelteKit, Flutter and more · Claude Code, Codex, Cursor · MCP server
Add a backend with email login to this app.
$ npx scribase init --yes
- framework
- next
- project
- my-org/my-app (production)
- env file
- .env.local (URL + public key)
- client
- lib/ client module written
- vercel
- keys set for all 3 environments
Illustration of the CLI summary. Names are placeholders; your output shows your own project.
Everything a database-and-sign-in backend has, plus
- Auth email on your own domain
- See everything included
Built for agents
One command or one MCP connection. Every change has an API call, an idempotency key and an approval step, so an agent can do it safely.
How agents use itFree to start
Free for 14 days, no card; one project stays free after that, with no time limit (0.5 GB database, 1 GB files). Then Hobby from $5 a project (1 GB database, 5 GB files), everything included, with no project limit.
See pricingYours to take
Export the whole backend as a bundle that boots elsewhere. Every restore ships its own proof.
What is includedSecure by default
Row level security is on from the first table. 16,326 exposed databases on an RLS-off-by-default backend (UpGuard via Cybernews, Sep 2026) is the problem a hard block at migration time, not a dashboard warning, is built to stop.
See the security modelA real query, and a real instant branch
This runs against a real Postgres project on our infrastructure, live. Nothing here is a recording.
Run a real query
Live Postgresselect id, label, created_at from demo_items order by id
Runs the same read-only SQL runner the console's SQL editor uses, scoped to one shared demo table.
Create an instant branch
Copy-on-writeHands you a real copy-on-write branch of the table above (forked ahead of time and kept ready), writes one row only the branch can see, then deletes the branch again.
Your agent can start before you sign up
With --temp, the agent gets a working project right away: database, sign-in, storage and realtime. It is free for 72 hours. Claiming takes a sign-up and a card (Hobby, $5 a month per project); the data and keys stay the same.
$ npx scribase init --temp --yes
What works, call by call
Change the URL and the key; keep your client code. This table lists only the calls our compatibility suite runs against the unmodified client, and marks the ones we re-ran against a fresh hosted project.
| Area | Client calls | What is checked | Status |
|---|---|---|---|
| Auth | auth.signUp, signInWithPassword, getUser, updateUser, refreshSession, signOut | Email and password sessions end to end; a wrong password answers invalid_credentials. | Run live01-auth |
| Auth | auth.admin.createUser, listUsers, deleteUser, generateLink; auth.verifyOtp | Admin calls work with the secret key only; the publishable key is refused (403). Magic links sign in through verifyOtp. | Run live01-auth |
| Auth | auth.signInWithOAuth, signInWithIdToken, signInAnonymously, getClaims | OAuth redirects from the project host once a provider is enabled; native Apple and Google id-token sign-in; anonymous sign-in once enabled. | In the suite01-auth, 02-oauth |
| Database | from().select, insert, update, delete, with eq, order, limit, count, single | CRUD and filters with the same error codes (single() on no rows is PGRST116). | Run live03-rest |
| Database | Row level security with auth.uid(); rpc() | Another user sees no rows, a forged user_id is refused with 42501, and rpc() runs as the caller. | Run live03-rest |
| Database | schema() for a non-public schema; embedded selects | A second schema is served once it is listed for the project; aliased and table-name embeds filter as documented. | In the suite03-rest |
| Storage | storage.from().upload, list, download, remove, createSignedUrl | Per-user folder policies hold, another user is refused, and a signed URL downloads with no key. | Run live04-storage |
| Storage | storage.createBucket, listBuckets, getPublicUrl, createSignedUploadUrl, resumable (TUS) uploads | Bucket management with the secret key, public bucket URLs, signed uploads and an upload that survives a dropped connection. | In the suite04-storage |
| Realtime | channel().on("broadcast").subscribe, send | A broadcast sent by one client reaches another. | Run live05-realtime |
| Realtime | channel().on("presence"), on("postgres_changes") | Presence sync sees a tracked peer; INSERT, UPDATE and DELETE on a row-level-security table reach only the row owner. | In the suite05-realtime |
| Edge Functions | functions.invoke | A deployed Deno function sees the caller role and body; a call with no key gets 401. Needs a claimed project: temporary projects refuse function deploys. | In the suite06-functions |
New tables get the Supabase default grants, with row level security forced on
A table you create in public is usable by anon, authenticated and service_role without a manual grant, the same as on Supabase, so the secret key reads it at once. Unlike Supabase, row level security is enabled and forced on every new public table automatically, so the anon and authenticated roles see no rows until you add a policy. (Changed on 16 November 2026: before that a new table answered 42501 until you granted it.)
A public table with no policy blocks the migration
npx scribase migrate refuses a run that would leave a public table without a row level security policy, instead of warning in a dashboard afterwards.
Edge Functions need a claimed project
A no-account temporary project serves the database, sign-in, storage and realtime, but refuses function deploys until it is claimed.
Keys that never reach the browser
Two places a secret can live: your own server, with the project's secret key, or a project secret that only your functions can read.
// app/api/admin/invite/route.ts (runs on the server only)
import { createClient } from '@supabase/supabase-js';
// No NEXT_PUBLIC_ prefix: this key never reaches the browser bundle.
const admin = createClient(process.env.SUPABASE_URL!, process.env.SUPABASE_SECRET_KEY!, {
auth: { persistSession: false, autoRefreshToken: false },
});
export async function POST(request: Request) {
const { email } = await request.json();
// Admin calls are refused (403) with the publishable key.
const { data, error } = await admin.auth.admin.createUser({ email, email_confirm: true });
if (error) return Response.json({ error: error.message }, { status: 400 });
return Response.json({ id: data.user.id });
}# Store a third-party key as a project secret. It is encrypted at rest;
# the list route returns names and versions, never values.
curl -X PUT "$SCRIBASE_API_URL/v1/organizations/$SCRIBASE_ORG/projects/$SCRIBASE_PROJECT/environments/$SCRIBASE_ENV/secrets/PAYMENT_API_KEY" \
-H "Authorization: Bearer $SCRIBASE_ACCESS_TOKEN" \
-H "Content-Type: application/json" \
-d "{\"value\": \"$PAYMENT_API_KEY\"}"
# {"name":"PAYMENT_API_KEY","version":1,"functions_refreshed":true}// supabase/functions/charge/index.ts (Deno, runs on Scribase)
Deno.serve(async (request) => {
const key = Deno.env.get('PAYMENT_API_KEY');
if (!key) return Response.json({ error: 'PAYMENT_API_KEY is not set' }, { status: 500 });
const { amount } = await request.json();
const charge = await fetch('https://api.payments.example/v1/charges', {
method: 'POST',
headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
body: JSON.stringify({ amount }),
});
// Only the result goes back to the app. The key stays on the server.
return Response.json({ ok: charge.ok }, { status: charge.ok ? 200 : 502 });
});- The publishable key (sb_publishable_) is the only key that belongs in app code. It can do what your row level security policies allow and nothing else.
- The secret key (sb_secret_) bypasses row level security. Keep it in a server-only variable; npx scribase doctor fails when it finds one in a public variable.
- Third-party keys go in project secrets. A function reads them with Deno.env.get; rotating a secret reaches deployed functions without a redeploy.
1 project free. Then from $5 a project.
| Plan | Price | Included | When idle |
|---|---|---|---|
| Free | $0, no time limit, no card | 1 project · 0.5 GB database · 1 GB files | Scales to zero when idle |
| Hobby | $5 per project a month | 1 GB database · 5 GB files per project | Scales to zero when idle |
| Pro | $25 per project a month | 8 GB database · 100 GB files per project | Stays warm |
| Studio | $199 a month | Up to 25 projects · 100 GB database · 250 GB files in total | Stays warm |
Every new account starts with 14 days of Hobby, no card; one project stays on Free after that. Paid plans are billed monthly for the most projects you had at once. The $1 card check happens only when you add a card, and is credited to your first invoice.
What people ask first
Does my existing client code work with Scribase?
Yes. The data-plane paths (/auth, /rest, /realtime, /storage, /functions/v1) are contract-tested against the standard JavaScript client, so existing client code works by changing the URL and keys.
What does my agent actually run?
npx scribase init. It detects the framework, creates or reuses a project, writes the env file and a small client module, and sets the keys on a linked Vercel project. With --temp it needs no account: the project is free for 72 hours and comes with a claim link.
How does pricing work?
One project is free with no time limit and no card (0.5 GB database, 1 GB files). Every new account also starts with 14 days of Hobby. After that, Hobby is $5 per project per month and Pro is $25 per project per month, billed monthly for the most projects you had at once, with the whole stack included. Studio is $199 a month flat for up to 25 projects. A card is only asked for when you move to a paid plan; the $1 card check at that checkout is credited to your first invoice.
Does a project ever pause?
An idle project on Free or Hobby scales to zero and wakes on the next request; it is not deleted for inactivity. Pro and Studio projects stay warm. Two cases do pause a project, with its data kept: when the 14-day trial ends, any project beyond your one free project pauses until you add a card, and an unpaid invoice stops new projects from being created.
Can I export my data and leave?
Yes. scribase export writes a bundle that boots elsewhere: schema, data, storage, auth users and policies, with a checksummed manifest.