Moving a Base44 app to Supabase: what it really takes
Supabase is the default answer to ‘where should my backend live’, so it is the first place many Base44 owners look. It can work, but it is not a transfer: Base44 apps are built on a document database with MongoDB-style queries and JSON security rules, and Supabase is Postgres. Here is the full mapping and a realistic plan.
Updated 9 min readBy the Unbase44 team
On this page
- 01The short version
- 02Why this is a rewrite, not an export
- 03The mapping, piece by piece
- 04A realistic plan
- 05Shortcuts, and their trade-offs
- 06Connecting Supabase to a Base44 app
- 07When Supabase makes sense, and when it doesn’t
- 08The alternative: keep the data model, change the owner
- 09Questions and answers
- 10Sources
The short version
There is no export from Base44 to Supabase. Base44 stores documents and queries them MongoDB-style, with security rules in JSON; Supabase is Postgres. So moving means rewriting the data layer: every query, every security rule and every function that calls the Base44 SDK. Every user also sets a new password, because Base44 doesn’t export password hashes. The mapping and a realistic plan are below.
Two other routes are worth knowing first. A Base44 app can use Supabase without leaving, through a connector or a backend function. And if what you want is your own backend rather than Postgres, the same app can move onto a Base44-compatible backend you own, with its records, IDs and users’ passwords: see the alternative.
Why this is a rewrite, not an export
Base44 and Supabase solve the same problems in different shapes. Base44 stores each entity as a collection of documents in a MongoDB-compatible database, queried with MongoDB operators (Entities overview). Supabase is Postgres: tables with fixed columns, queried with SQL or through its REST layer.
That difference runs through everything your app does:
- Data shape. A Base44 record can hold nested objects and lists, and its schema can change without a migration. In Postgres every field needs a column and a type, and nested data becomes
jsonbor a separate table. - Queries. Your pages and functions filter records with MongoDB-style operators such as
$in,$or,$gteor$regex. Every one of those calls has to be rewritten for Supabase’s query builder or SQL. - Security. Base44 rules are JSON conditions stored with each entity, such as “
created_byequals{{user.email}}“ or auser_conditionon the user’s role (Entity security). Supabase uses Postgres row-level security policies written in SQL. Each rule has to be translated by hand and tested, including Base44’s specific behaviour: denied lists come back empty and denied reads look like “not found”. - Sign-in. Base44 doesn’t hand out password hashes, and its documentation states that app users can’t be exported. Your users will need to set a new password or sign in by email link on Supabase.
- Functions. Base44 functions and Supabase Edge Functions both run on Deno, which helps. But Base44 functions call the Base44 SDK (to read records, act as a service role or send email), and each of those calls needs replacing.
- Integrations.
InvokeLLM,SendEmail,UploadFileandGenerateImageare Base44 services. On Supabase you call an AI provider, an email provider and Supabase Storage directly, with your own keys.
None of this is exotic. It’s just a lot of work, and all of it has to be right.
The mapping, piece by piece
| Base44 | Supabase equivalent | Effort |
|---|---|---|
| Entity (collection of documents) | Table, with jsonb for nested data |
Medium: design each table |
| Record IDs (strings) | text primary key |
Low, if you keep the original IDs |
created_date / updated_date |
created_at / updated_at columns |
Low |
created_by (creator’s email) |
A user ID column, or keep the email | Medium: rules depend on it |
SDK filter() with Mongo operators |
supabase-js queries or SQL | High: every call site |
| Row- and field-level rules (JSON) | RLS policies (SQL), column privileges | High: translate and test |
| Users and roles | Supabase Auth plus a profiles table | Medium |
| Passwords | Not transferable | Every user resets or uses email links |
| Google or Microsoft sign-in | Supabase Auth providers with your OAuth clients | Low to medium |
| Backend functions (Deno + Base44 SDK) | Edge Functions (Deno + supabase-js) | Medium to high |
| Automations and workflows | Supabase Cron, database webhooks, Edge Functions | High for multi-step workflows |
subscribe() realtime |
Supabase Realtime channels | Medium |
| Uploaded files | Supabase Storage, with every stored URL rewritten | Medium |
| AI, email, image integrations | Direct calls to providers | Medium |
| Agents and conversations | Your own implementation | High |
A realistic plan
If you do go this way, this order keeps risk under control.
- Take an inventory. List every entity and its fields, every security rule, every function and what it calls, every automation or workflow, the integrations you use (AI, email, uploads), your connectors and your agents. Base44’s dashboard shows most of it; an export of the code shows the rest.
- Design the schema. For each entity decide which fields become columns and what stays in
jsonb. Keep Base44’s IDs astextprimary keys so references between tables still line up, and note thatcreated_byholds an email address, not a user ID. - Export the data. Use the dashboard’s CSV export per table, or page through the API. Remember that a single request returns at most 5,000 items and doesn’t say when it was cut short (Apps API: entities), so paginate and compare counts.
- Rebuild the security rules as RLS policies. Test each one with an admin, an ordinary user and an anonymous visitor. This is where rebuilt apps most often leak data.
- Replace the data layer in the frontend. Many teams write a small wrapper with the same method names as the Base44 SDK (
list,filter,get,create,update) so pages change as little as possible. Filters with operators are where wrappers fall short, so search the code for them. - Port the functions. Keep the Deno code, swap the Base44 SDK calls for supabase-js, and move secrets into Supabase’s secret store.
- Replace the integrations. Choose an AI provider, an email provider and a storage layout, and update every call.
- Move the users. Import emails, names and roles, then send everyone a password-reset or sign-in link. Warn them first; unexpected reset emails look like phishing.
- Copy the files. Upload them to Supabase Storage and rewrite every URL stored in your records.
- Run both side by side, then cut over. Point a test domain at the new app, click through every flow, then switch your real domain.
For a small app with a handful of entities, a developer comfortable with Supabase might do this in a few weeks. Apps with many functions, workflows or agents take longer.
Shortcuts, and their trade-offs
Compatibility shims (the “migration SDK” people search for). Base44 doesn’t publish a migration SDK or any tool that exports to Supabase. What it publishes is its own client, @base44/sdk, MIT-licensed, which talks only to Base44’s API. On npm you’ll find community packages that copy the shape of that SDK (entities.X.list(), filter(), auth.me() and so on) but send the calls to Supabase through supabase-js. They can shrink the frontend rewrite, but they only cover the frontend’s calls. They don’t move your data, users, security rules, functions, workflows or files, and their coverage of query operators, Base44’s security behaviour and newer SDK features varies. Test every screen, especially anything that filters.
AI coding agents. Claude Code or Cursor can do much of the mechanical work: rewriting call sites, generating table definitions, porting functions. They are much less reliable at security rules and data edge cases, which need a person who understands both systems.
Rebuilding from scratch in a Supabase-based builder. Tools like Lovable and Bolt build on Supabase. Re-prompting your app there recreates the interface quickly, but the data, users and business logic still need everything above. See moving from Base44 to another builder.
Connecting Supabase to a Base44 app
Some owners don’t want to leave Base44 at all; they want their Base44 app to use data that already lives in Supabase. That’s possible in three ways, and none of them changes where the Base44 app’s own data lives.
1. The Supabase connector. Base44 added Supabase to its connector catalog in March 2026 (product changelog). The connectors catalog describes it as read-only: browse the schema, read tables and see project status. When you connect it, it asks for read access to your Supabase projects, secrets and database. Connectors need the Builder plan or higher. It suits dashboards and reports over Supabase data.
2. A backend function that calls Supabase. Base44 functions run on Deno and can import npm packages with an npm: specifier (Backend functions), so a function can use supabase-js to read and write. Store the Supabase key in your app’s secrets, never in page code. Supabase’s own API keys guide explains why: a secret key bypasses every row-level security policy, so it belongs on a server only. Backend functions, and calls to outside APIs generally, need the Builder plan or higher (Managing your app data).
3. Calling Supabase from the browser. Base44 lets you add npm packages to your app, so the frontend could use supabase-js with Supabase’s publishable key. That key is public by design, and only Supabase’s row-level security decides what it can reach, so enable RLS on every table first.
What none of these does:
- Replace Base44’s database. Your entities stay in Base44’s own database, and its documentation doesn’t describe any way to put them somewhere else. You end up with two databases and two sets of security rules to keep consistent.
- Move your users. Sign-in stays with Base44, and Supabase Auth knows nothing about your Base44 users.
- Get you off the plan. All of the above runs on Base44, under its plans and credits.
If the goal is eventually to leave, treat a connection like this as a bridge, not a migration.
When Supabase makes sense, and when it doesn’t
It makes sense when you want Postgres for its own sake (SQL reporting, a data warehouse, a team that already knows it), when you were planning a substantial rebuild anyway, or when you have a developer and a few weeks.
It’s the wrong tool when you want the app you already have, running the same way, soon; when you have many users whose passwords you don’t want to reset; or when your app leans on MongoDB-style queries, nested data, workflows or agents.
The alternative: keep the data model, change the owner
If what you want is independence rather than Postgres, you don’t have to translate anything. Unbase44 moves the whole app to a documented, Base44-compatible backend on MongoDB, in accounts you own. Your code keeps calling the same API, your records keep their shape and IDs, the security rules are enforced the same way, and your users keep their passwords.
And if you want Postgres later, you’ll be doing that migration from a repository and a database you control, on your own schedule, instead of as the price of leaving.
Questions and answers
Can Base44 export directly to Supabase?
No. Base44 exports code (ZIP or GitHub, on the Builder plan and up) and data as CSV, one table at a time. Its migration feature works the other way: it imports projects into Base44 from Supabase-based tools such as Lovable and Bolt.
Can I connect Supabase to Base44?
Yes, alongside Base44’s own database rather than instead of it. Base44’s Supabase connector reads schemas and tables, and a backend function can read and write with supabase-js and a key kept in your app’s secrets. Both need the Builder plan or higher, and your Base44 entities and users stay on Base44.
Is there a Base44 to Supabase migration SDK?
Not from Base44. Its SDK, @base44/sdk, only talks to Base44’s API. Community packages on npm imitate that SDK on top of supabase-js, which reduces the frontend rewrite, but they don’t move data, users, security rules or functions, and you should test every query that filters.
Will my Base44 functions run on Supabase Edge Functions?
Both run Deno, so the language and runtime carry over. The functions still need rewriting wherever they call the Base44 SDK, which is usually most of what they do.
Will my users keep their passwords if I move to Supabase?
No. Base44 doesn’t release password hashes, so users will set a new password or sign in with an email link. Plan the communication carefully.
Does Unbase44 migrate apps to Supabase?
No. We keep your app on the kind of database it was built for, MongoDB, with a backend that answers the same API. That’s why the app isn’t rewritten (its frontend gets only a few small patches, listed in the repository’s docs/MIGRATION.md) and passwords carry over.
Sources
Checked on November 10, 2026. Base44 changes quickly; if something here is out of date, tell us.
- Entities overview (MongoDB-compatible database)
- Entity security (row- and field-level rules)
- Apps API: entities (5,000-record cap)
- Privacy and security (app users can’t be exported)
- Migrating a project to Base44 (imports from Lovable and Bolt)
- Backend functions (Deno,
npm:imports) - Connectors catalog (Supabase connector, read-only, Builder plan)
- Base44 product changelog (Supabase connector added, March 2026)
- Managing your app data (external APIs need the Builder plan)
- Adding and using npm packages
- Base44 JavaScript SDK on GitHub (MIT licence)
- Supabase: API keys (publishable keys, secret keys and row-level security)