Serverpod vs Supabase
Serverpod is an open-source Supabase alternative for Dart-first teams, giving you an owned PostgreSQL backend with type-safe endpoints and a generated client on top.
Serverpod vs Supabase at a glance
Both are open-source options for running a PostgreSQL backend. The difference lies in architecture: Supabase lets clients query the database directly, with queries secured by SQL policies. Serverpod puts a typed Dart API between your app and the data.
| Capability | Serverpod | Supabase |
|---|---|---|
| Language | ✓ Dart on the server and the client | ✓ Flutter SDKs, server logic in SQL and TypeScript |
| Type safety | ✓ End-to-end, checked at compile time | ✗ Manual in Dart, no official codegen |
| Database | ✓ PostgreSQL with a type-safe ORM | ✓ PostgreSQL, queried from the client |
| Authorization | ✓ Scopes on Dart endpoints | ✓ SQL row-level security |
| Authentication | ✓ Email, social sign-in, passkeys, and Firebase | ✓ Email/Password, Magic Link, Social, SAML, MFA, and Web3 |
| Real-time | ✓ Typed WebSocket streams | ✓ Postgres Changes, Broadcast, Presence |
| Offline sync | ✓ Local SQLite with typed sync | ✗ Third-party tools, such as PowerSync |
| Generated Dart client | ✓ Generated from your endpoints | ✗ Not supported, community tools only |
| Hosting | ✓ Docker anywhere, or Serverpod Cloud | ✓ Managed cloud, or self-host |
| Open source | ✓ BSD-3 packages, SSPL server | ✓ Apache-2.0 |
| Pricing model | Free to self-host, flat Cloud tiers | Free tier, Pro $25 per month plus usage |
What is Supabase?
Supabase is an open-source backend platform built around PostgreSQL, providing instant APIs over your tables, authentication, real-time subscriptions, storage, and Edge Functions. Its dashboard and SQL editor are strong, and it serves clients on many platforms. It suits teams that want to work close to SQL.
What is Serverpod?
Serverpod is an open-source backend framework for Flutter and Dart, and a Supabase alternative for teams that want their server logic in Dart. You write endpoint methods, Serverpod generates a type-safe client, and your data lives in PostgreSQL managed through models and migrations.
How they compare
Both give you PostgreSQL you own. The real decision is where your backend logic lives. In SQL policies and TypeScript functions, or in Dart next to your Flutter code.
Full-stack Dart or SQL and TypeScript
In Supabase, business rules live in row-level security policies written in SQL, with more complex logic implemented in TypeScript Edge Functions on a Deno-based runtime. In Serverpod, everything is Dart: endpoint methods handle the logic, share models with your Flutter app, and are checked by the same analyzer.
Working with PostgreSQL
Supabase exposes the database to clients, where the app queries tables through the SDK, and policies decide row access. It is a fast way to put an API on an existing database. Serverpod treats the database as the server’s concern, using YAML models that become tables, typed queries, and versioned migrations, while clients only see endpoints.
Type safety across the stack
Supabase generates types for TypeScript, Go, Swift, and Python, but not for Dart, so a Flutter app must work with untyped rows or use community tooling. Serverpod generates the Dart code on both sides.
final orders = await supabase
.from('orders')
.select('*, customer(*)');
final country = orders.first['customer']['country'];
The Serverpod equivalent returns typed models, checked at compile time:
final orders = await Order.db.find(
session,
include: Order.include(customer: Customer.include()),
);
final country = orders.first.customer?.country;
Authentication
Supabase’s authentication is a real strength: social providers, SAML single sign-on, multi-factor authentication, and Web3 sign-in. Serverpod ships sign-in with email, Google, Apple, Facebook, GitHub, Microsoft, and passkeys. Firebase Authentication is also supported as an identity provider. Users and sessions are stored in your own database and exposed through the same typed client as the rest of your API.
Real-time
Supabase Realtime offers Postgres Changes, Broadcast, and Presence, which can be subscribed to from the client SDK. Serverpod’s model is a typed stream: an endpoint method returns a Stream of your models over a managed WebSocket. Fan-out across servers runs through Redis.
Pricing
Supabase Cloud has a free tier and a Pro plan at $25 per month (which includes a $10 compute credit), with usage-based charges beyond the included quotas. A spend cap is on by default. Serverpod is free to self-host, and Serverpod Cloud offers flat monthly tiers starting at $19 per month. Both can be self-hosted with Docker, which keeps the bill structural rather than per-request. Current Supabase rates are on the Supabase pricing page.
Migrating from Supabase
Both systems store plain PostgreSQL, so your data moves with standard dump and restore tools. The work is the API layer: client-side queries become endpoint methods, and row-level security policies become authorization checks in Dart. Your Flutter app swaps SDK calls for generated client methods, which usually deletes parsing code.
Point Serverpod at a copy of your database and move one feature first. Both backends speak PostgreSQL, so nothing about the data format has to change.
Everything you get with Serverpod
Why teams choose Serverpod
Frequently asked questions
Is Serverpod a Supabase alternative?
Yes. Both are open-source backends on PostgreSQL. Serverpod is a Supabase alternative for Flutter teams that want backend logic in Dart with a generated type-safe client, rather than client-side SQL and policies.
Can I migrate from Supabase to Serverpod?
Yes. The data moves with standard PostgreSQL tools. You rebuild the access layer: SDK queries become endpoint methods, and policies become Dart authorization checks.
Is Serverpod open source like Supabase?
Yes. Serverpod’s packages are BSD-3-licensed, except for the main server package, which uses the SSPL license. Supabase is Apache-2.0. Both are free to self-host.
Do I need row-level security policies with Serverpod?
No. Clients never query the database directly. Authorization lives in Dart, with requireLogin and scopes on the endpoints that hold your logic.