scribase
The agent-first backend

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

Sample run · illustrative output

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
Backend is liveYou shipped Postgres, Auth, Storage and Realtime.

Illustration of the CLI summary. Names are placeholders; your output shows your own project.

Everything a database-and-sign-in backend has, plus

Try it now, no account

A 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 Postgres
select 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-write

Hands 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.

Open the full demo

Try it free, no account

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.

How temporary projects work

$ npx scribase init --temp --yes

temporaryexpires in 72 hoursclaimconsole.scribase.com/claim/…
Claim it and it is yours: same data, same keys.
Works with supabase-js

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.

Unmodified @supabase/supabase-js v2. Only calls our compatibility suite runs are listed. “Run live” rows were re-run on 2026-11-16 against a fresh hosted project.
AreaClient callsWhat is checkedStatus
Authauth.signUp, signInWithPassword, getUser, updateUser, refreshSession, signOutEmail and password sessions end to end; a wrong password answers invalid_credentials.Run live01-auth
Authauth.admin.createUser, listUsers, deleteUser, generateLink; auth.verifyOtpAdmin calls work with the secret key only; the publishable key is refused (403). Magic links sign in through verifyOtp.Run live01-auth
Authauth.signInWithOAuth, signInWithIdToken, signInAnonymously, getClaimsOAuth 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
Databasefrom().select, insert, update, delete, with eq, order, limit, count, singleCRUD and filters with the same error codes (single() on no rows is PGRST116).Run live03-rest
DatabaseRow 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
Databaseschema() for a non-public schema; embedded selectsA second schema is served once it is listed for the project; aliased and table-name embeds filter as documented.In the suite03-rest
Storagestorage.from().upload, list, download, remove, createSignedUrlPer-user folder policies hold, another user is refused, and a signed URL downloads with no key.Run live04-storage
Storagestorage.createBucket, listBuckets, getPublicUrl, createSignedUploadUrl, resumable (TUS) uploadsBucket management with the secret key, public bucket URLs, signed uploads and an upload that survives a dropped connection.In the suite04-storage
Realtimechannel().on("broadcast").subscribe, sendA broadcast sent by one client reaches another.Run live05-realtime
Realtimechannel().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 Functionsfunctions.invokeA 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.

Server-side secrets

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.

Your server: admin work with the secret keyts
// 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 secretbash
# 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}
A function reads it (needs a claimed project)ts
// 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.
Pricing

1 project free. Then from $5 a project.

PlanPriceIncludedWhen idle
Free$0, no time limit, no card1 project · 0.5 GB database · 1 GB filesScales to zero when idle
Hobby$5 per project a month1 GB database · 5 GB files per projectScales to zero when idle
Pro$25 per project a month8 GB database · 100 GB files per projectStays warm
Studio$199 a monthUp to 25 projects · 100 GB database · 250 GB files in totalStays 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.

Questions

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.

Your next app already has a backend.

You just have to ask for it.

Get a backend, free