# Supabase alternative with the same client and per-project pricing

> Scribase runs the Supabase API (supabase-js, Auth, Storage, Realtime, REST, Functions) on hosted Postgres with instant branching, from $5 a project a month (Pro $25). No 2-project free-tier cap.

Source: https://scribase.com/supabase-alternative

Scribase serves the same REST, Auth, Storage, Realtime and Functions endpoints, so an app moves by changing its URL and keys. Projects are priced per project, $5 a month on Hobby or $25 on Pro, with no 2-project cap on the free tier; idle projects scale to zero instead of pausing, and every database can branch like a Git repo.

## Why teams look for a Supabase alternative

Most teams that search for an alternative are not unhappy with the Supabase API. They like supabase-js, row level security and the auth model. What they want to change is around it: the Free plan's limit of 2 active projects per organization, free projects that are paused after a week of inactivity, a Pro plan that bills $25/month per organization plus its own compute line per project (so a second project adds its own charge on top), and database branches that need extra setup.

Scribase keeps the API and changes those things. There is no cap on how many projects an organization can create, idle projects scale to zero instead of pausing, and the paid price is per project (Hobby from $5, Pro $25) with no separate compute meter to add up. That is the whole pitch, so the rest of this page is a list of what is the same, what is different, and what is not finished yet.

## Sources

- [Supabase: Pricing](https://supabase.com/pricing)

## What stays the same: the client and the data model

Your app keeps calling createClient(url, key). The tables, policies, auth.users, storage.objects and realtime channels are the same Postgres objects, so policy code such as auth.uid() = user_id runs unchanged.

_The only change in a Next.js or Expo app_

```ts
import { createClient } from '@supabase/supabase-js'

// Before: https://<ref>.supabase.co
// After:  the Project URL and publishable key from the Scribase console
export const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
)
```

_Verified against the hosted service with the official client libraries (compat run of 2026-10-06)_

| Area | Works on Scribase today |
| --- | --- |
| Database | Postgres 17 per project, REST (PostgREST) and GraphQL (pg_graphql) |
| Auth | Email and password, magic links, OTP email, OAuth providers, anonymous users, TOTP factors, passkeys, SAML SSO, auth hooks, Web3 sign-in |
| Storage | Buckets with RLS, signed URLs, resumable uploads, image transforms, S3 protocol keys |
| Realtime | Broadcast, presence and postgres_changes with RLS |
| Functions | Edge functions: deploy, invoke, secrets, verify_jwt |
| Extensions | pgvector, pg_cron, pgmq queues, pg_net, Vault and more (see the extensions directory) |
| Tooling | Type generation (TypeScript, Swift, Kotlin, Dart, Python), logs, advisors, backups and point-in-time restore, custom domains, CLI and MCP server |
| Client SDKs | supabase-js, supabase-swift, supabase-kt, supabase-flutter and supabase-py run unmodified |

## What is different

- No project-count cap: Supabase caps a Free organization at 2 active projects. A Scribase organization can create as many projects as it wants, free for 14 days with no card, and nothing after that limits the count.
- Price: per project per month, $5 on Hobby or $25 on Pro, billed for the most projects you had at once in the month, with no separate compute meter per project. Staging and preview environments are part of the project.
- Idle projects scale to zero and wake on the next request. They are not paused, and nobody has to restore them from a dashboard.
- Branching is copy-on-write: a branch gets its own URL and keys and carries the parent rows without copying them first. You can branch from a past point in time, mask columns in a branch, and give a branch an expiry.
- Your coding agent can set the backend up: the CLI and MCP server create projects, run migrations and open branches with scoped tokens.
- Export is a button: a bundle with the schema, data, auth users and storage objects, so leaving is as easy as arriving.
- A migration that ships a public table with row level security off, or RLS on with no policy attached, is refused before it ever touches the database — not a warning badge, a hard 409 the deploy has to fix. Supabase Studio flags a disabled-RLS table in the table editor, but `supabase db push` and raw `psql` both apply the same migration anyway; the gap between "flagged" and "blocked" is exactly how most RLS leaks in AI-generated Supabase apps ship to production.
- Per-customer usage metering is a database primitive, not a separate billing vendor you have to wire up: record one event per meter per customer (`POST .../usage-meters/record`, idempotent on a transaction id) and read the aggregate back per customer per meter (`GET .../usage-meters/summary`), both under row level security in your own project. Neither Supabase nor Neon ships anything like it — a team on either has to stand up Stripe metering, Lago, Orb or Metronome first just to answer "how much did customer X actually use this period."
- A migration that runs `ALTER COLUMN ... TYPE ...` on a table that already has rows is refused before Postgres ever sees the statement: that change always takes an `ACCESS EXCLUSIVE` lock to rewrite every row, which blocks every read and write on the table for as long as the rewrite runs. `SET NOT NULL` on an existing column gets the same warning, since proving no row is null takes that same full-table lock for the scan. A migration that runs `CREATE INDEX CONCURRENTLY` — the textbook fix for exactly that kind of lock — is refused too, but for a different reason: every migration here applies inside one transaction together with its ledger row, and Postgres refuses to even attempt `CONCURRENTLY` once a transaction is already open, so without this check the same migration would reach Postgres and fail there instead of at lint time. Neither `supabase db push` nor Neon's branch/merge flow checks for any of this before a migration runs — it's Postgres's own documented lock and transaction behavior, and it's exactly how a routine-looking migration takes down a live table or fails outright.

## Sources

- [Supabase: Pricing](https://supabase.com/pricing)

## When to stay on Supabase

A fair comparison says where the other platform is still the right call, not just where it is not:

- You need a specific AWS region, multi-region, or read replicas: Supabase has 19 regions (checked live 2026-11-11). Scribase runs on one Oracle VM in Frankfurt, shared with other products — there is no region choice yet.
- You need SOC 2, ISO 27001, a HIPAA BAA, or an uptime SLA: Supabase Team ($599/month) has all four. Scribase has none of these yet — see the honest compliance table on /security.
- You want to self-host for free: Supabase self-hosting is documented and free. Scribase's core repository is private; self-hosting is by written agreement only.
- You run two or more always-on production projects: Supabase Pro plus one extra Micro instance runs about $35/month. Two Scribase Pro projects are $50/month ($25 each) — more, not less, once you are past one project. Two Hobby projects are $10/month, but Hobby has smaller caps and scales to zero when idle, so it is not the like-for-like always-on comparison.
- You depend on Supabase Pipelines (managed CDC), Supabase-specific dashboard features, or the size of its community, third-party tutorials and integrations.
- You need proven scale: Scribase has a handful of external users and no meaningful revenue yet. Nothing on this page claims otherwise.

## Sources

- [Supabase: Regions](https://supabase.com/docs/guides/platform/regions)
- [Supabase: Pricing (Team plan)](https://supabase.com/pricing)
- [Supabase: Self-hosting](https://supabase.com/docs/guides/self-hosting)

## What does not work yet

We publish the gaps instead of hiding them. As of the last check:

- Phone and SMS one-time codes: the allow list works, the managed SMS sender is not switched on yet.
- Direct Postgres connections from the internet (ports 5432 and 6543, for psql or pg_restore): not open yet. Migrations, the console SQL editor and the HTTP serverless driver work today.
- Read replicas and foreign data wrappers to remote servers: built, not yet proven on the hosted service.

## Move in one command

scribase-migrate is a small, separate command-line tool (no install, runs with npx) that moves a Supabase project's Postgres schema and data, auth.users with password hashes intact, and storage buckets and objects in one run, then verifies the copy.

_Documented at docs.scribase.com/docs/migrate_

```sh
npx --yes git+https://rithub.dev/caelum0x/scribase-migrate.git supabase \
  --to <org>/<project> --create-project \
  --source-ref <project-ref> \
  --source-url "postgres://postgres:<password>@db.<project-ref>.supabase.co:5432/postgres" \
  --source-service-key "<service_role key>" \
  --verify-login-email you@example.com
```

## How to move a Supabase project

1. **Dry run** — The importer reads your project and prints the tables, rows, users, objects and bytes it would move, plus any policy that admits every row. It writes nothing.

```sh
scribase import supabase --project-ref <your-ref> \
  --org acme --project app --env production \
  --connection-string "$SOURCE_DB_URL" --service-key "$SOURCE_SERVICE_KEY" --dry-run
```

2. **Run it and read the report** — Schema, auth users with their bcrypt hashes, data, policies and storage move in order. The run ends with row counts and checksums for every table, so you can see that nothing was lost.

3. **Swap two environment variables** — Point SUPABASE_URL and SUPABASE_ANON_KEY at the new project. Users keep their passwords.

## FAQ

**Is Scribase a fork of Supabase?**

Scribase is built from open-source components, including several from the Supabase project (Apache-2.0 licensed), plus its own control plane, branching engine and billing. It is a separate company and is not affiliated with or endorsed by Supabase.

**Do I have to change my code?**

No for the client: supabase-js and the Swift, Kotlin, Flutter and Python SDKs work with a new URL and key. If you call the Supabase management API or CLI directly, use the scribase CLI or the /v1 API instead.

**Do my users have to reset their passwords?**

No. The importer copies auth.users with the same ids and the bcrypt hashes byte for byte, plus linked identities and TOTP factors.

**How much does it cost?**

Per project: $5 a month on Hobby, $25 on Pro. The bill is for the most projects you had at once during the month. There is no separate charge for branches or preview environments inside a project.

**Is there a project limit on the free tier, like Supabase's 2-project cap?**

No. Supabase's Free plan caps an organization at 2 active projects and bills Pro at $25/month per organization plus $10/month in compute credits that only covers one project, so a second project adds its own compute charge. Scribase has no cap on how many projects an organization can create: every new organization starts free for 14 days with no card, and after that each project is $5 (Hobby) or $25 (Pro) a month, with no separate compute meter.

**Can I leave again?**

Yes. Export produces a bundle with the schema, data, auth users and storage objects, which you can restore into any Postgres-based backend.

**Does Scribase actually stop an insecure migration, or just warn like Supabase Studio does?**

It blocks it. A migration that creates a public-schema table without both enabling row level security and attaching at least one policy gets refused with a 409 before any statement runs against the database. Supabase's own deploy path (`supabase db push`, or a raw psql apply) has no equivalent check and applies the migration as written; Studio's table editor shows a warning badge after the fact, once the table already exists.

**Does Scribase meter my customers' usage, or do I still need a separate billing vendor for that?**

It's built in. Record a usage event for any of your own customers — a Dodo, Stripe or Creem customer id, an org id, anything you already bill by — against a meter you name, like `ai_tokens` or `api.calls`, and the project aggregates it per customer per meter with no extra service to stand up. Neither Supabase nor Neon has an equivalent; both leave usage metering to a separate vendor like Lago, Orb or Metronome.

**Can a migration lock up a live table, or does Scribase check for that before running one?**

It checks first. Changing an existing column's type is refused outright — that statement takes Postgres's strongest lock to rewrite every row, blocking all reads and writes for the whole rewrite. Adding a `NOT NULL` constraint to an existing column is flagged with a warning for the same reason, since confirming no row is null takes that same lock for the scan. Neither Supabase's CLI nor Neon's branch/merge flow checks for this before applying a migration; a routine-looking schema change can otherwise take a production table offline for however long the rewrite or scan takes.

## Related

- [Backend as a service compared](https://scribase.com/backend-as-a-service)
- [Appwrite alternative](https://scribase.com/appwrite-alternative)
- [Migrate from Supabase](https://scribase.com/migrate/supabase)
- [Neon alternative](https://scribase.com/neon-alternative)
- [Render alternative](https://scribase.com/render-alternative)
- [Supabase too many connections](https://scribase.com/supabase-too-many-connections)
- [Supabase vs Neon](https://scribase.com/supabase-vs-neon)
- [Scribase vs Supabase vs Neon](https://scribase.com/scribase-vs-supabase-vs-neon)
- [RLS policy examples](https://scribase.com/supabase-rls-policy-examples)
- [How Postgres branching works](https://scribase.com/postgres-branching)
- [Postgres extensions](https://scribase.com/extensions)
- [Usage meters (API reference)](https://docs.scribase.com/docs/api/usage-meters)
- [Migration lint rules (API reference)](https://docs.scribase.com/docs/api/migrations)
- [Pricing](https://scribase.com/pricing)