To migrate from Supabase to WoWSQL, you move four things separately: your public schema and data (with pg_dump and psql), your auth users (they re-create their accounts or sign in again with OAuth, and you re-map ownership), your storage files (with a short copy script), and your client code (from supabase-js to @wowsql/sdk). Both platforms run PostgreSQL, so tables, rows, and most Row Level Security policies come across. Auth sessions, password hashes, signed URLs, and Edge Functions don't. This guide covers each step and marks clearly which parts follow WoWSQL's docs, which are standard Postgres, and which you should ask support about. Facts were checked on 21 November 2026.
Key facts
- What WoWSQL gives you to connect: the project overview's Connect menu shows the project URL (
https://your-project-slug.wowsqlconnect.com), the anon key, and a direct Postgres connection string (postgresql://USER:[YOUR-PASSWORD]@db.your-project-slug.wowsqlconnect.com:5432/postgres) (dashboard docs).- No one-click Supabase importer is documented. The database step below uses standard Postgres tools (
pg_dumpandpsql) against that connection string.- Auth users: WoWSQL's docs don't document a way to import users or bcrypt password hashes. Users sign up again, reset their password, or sign in with the same OAuth provider. For bulk hash import, contact support@wowsql.com.
- Storage: public and private buckets, with uploads through
WowSQLStorage. WoWSQL storage does not issue presigned URLs (storage docs), so SupabasecreateSignedUrlcalls need a replacement.- Plans (pricing, USD): Free $0 (256 MB database, 512 MB files, 10,000 MAU), Pro $25/month (10 GB database, 100 GB files, 100,000 MAU, daily backups kept 7 days), Scale $99/month.
- Regions: Mumbai (
ap-south-1), US East (us-east-1), and Frankfurt (eu-central-1). There is no UK region.
Before you start: is moving worth it?
Supabase is a strong product, and many teams should stay on it. Read WoWSQL vs Supabase and WoWSQL vs Neon first if you are still deciding. Teams usually move for one of these reasons:
- Billing shape. Supabase bills compute separately per project on top of the plan (Pro from $25/month with $10 of compute credits, as of Nov 2026, supabase.com/pricing). WoWSQL plans are flat $0 / $25 / $99, plus listed overage for extra MAU, storage, and transfer.
- Region. Your users are in India, the US East coast, or the EU, and you want one of those three regions.
- Open source and self-hosting. WoWSQL's self-hosted edition is Apache-2.0 (github.com/WoWSQL/WoWSQL). Supabase can also be self-hosted. See the self-hosted comparison.
Stay on Supabase if you depend on point-in-time recovery, database branching, its GraphQL endpoint, Vault, or a region WoWSQL doesn't offer. The comparison table further down lists these.
Step 1: Inventory what your Supabase project uses
| On Supabase | Moves how | Status on WoWSQL |
|---|---|---|
Tables, views, functions, and data in public |
pg_dump → psql (Step 3) |
Standard Postgres, works with the direct connection string |
RLS policies using auth.uid() |
Come across inside the schema dump | WoWSQL docs use auth.uid() in policies. Check any other auth.* helpers you use. |
auth.users, identities, sessions |
Re-create users (Step 4) | No documented user or hash import |
Triggers on auth.users (for example "create a profile on sign-up") |
Re-implement in app code | Not carried by a public dump |
| Storage buckets and files | Copy script (Step 5) | Public/private buckets. No presigned URLs. |
Storage RLS policies on storage.objects |
Re-design | The managed docs describe bucket-level public/private access, not per-object policies |
| Realtime on tables | Enable per table (Step 6) | POST /realtime/v1/enable, payloads capped at 64 KiB |
| Edge Functions (Deno) | Move to your own server or serverless host | Edge Functions are listed on Pro and Scale, but the docs we checked have no porting guide |
Extensions (pg_cron, vector, postgis, etc.) |
Re-enable if available | Enabling extensions needs Pro or Scale. vector, postgis, and pg_cron are listed as "optional (if installed on the server)" (docs). Confirm in your dashboard. |
| Vault secrets / pgsodium columns | Decrypt on Supabase, store again | No equivalent documented |
| GraphQL calls | Rewrite against REST | WoWSQL has no GraphQL API |
Also check your database size. The WoWSQL Free plan has 256 MB of database storage and 512 MB of file storage. Anything larger needs Pro (10 GB database, 100 GB files).
Step 2: Create the WoWSQL project
- Sign up at app.wowsql.com/signup and create a project. Choose the region closest to your users: US East, Frankfurt (the usual choice for UK and EU users), or Mumbai.
- Set a database password when you create the project. It must be 8–128 characters with an upper-case letter, a lower-case letter, and a digit. WoWSQL won't show it again; you can reset it under Project Settings → Database password (troubleshooting).
- Open Authentication and enable it. The setup asks for a JWT secret of at least 32 characters and creates the auth tables.
- From the Connect menu, copy the project URL, the anon key (
wowsql_anon_…), and the direct connection string. The service role key (wowsql_service_…) is in Project Settings. It bypasses RLS, so keep it on servers and in migration scripts only.
Do a trial run into a scratch project first. On the Free plan there are no platform backups (legal/backups), so a bad import into a real project can't be rolled back by support.
Step 3: Move the schema and data with pg_dump and psql
WoWSQL's docs don't include a Supabase-specific import guide. What follows is the standard Postgres method: dump from Supabase's direct connection string and restore with psql into WoWSQL's. Use a pg_dump whose major version is the same as, or newer than, the Supabase server. Run select version(); on both databases first.
Supabase's own supabase db dump command skips Supabase-managed schemas such as auth and storage, and its default dump has no data (Supabase CLI reference). We dump only public with plain pg_dump instead, so the file has no Supabase roles or owners:
# Supabase: Connect panel → direct connection string
export SUPABASE_DB_URL='postgresql://postgres:[PASSWORD]@db.[PROJECT-REF].supabase.co:5432/postgres'
# WoWSQL: Connect menu → direct connection string
export WOWSQL_DB_URL='postgresql://USER:[PASSWORD]@db.your-project-slug.wowsqlconnect.com:5432/postgres'
# One file with schema + data for the public schema, no owners or grants
pg_dump "$SUPABASE_DB_URL" \
--schema=public \
--no-owner \
--no-privileges \
--file=public.sql
One file is easier than separate schema and data files. pg_dump writes the table data before it adds foreign keys, so rows load in any order.
Before you restore, open public.sql and fix three things:
- Foreign keys to
auth.users. Supabase apps often haveuser_id uuid references auth.users(id). User IDs will change on WoWSQL (Step 4), so delete thoseADD CONSTRAINT … REFERENCES auth.usersstatements. Keep theuser_idcolumns; RLS policies will still enforce ownership. - Extensions. Remove
CREATE EXTENSIONlines for anything you haven't enabled on WoWSQL.gen_random_uuid()is built into Postgres and needs no extension. CREATE SCHEMA public. If the restore stops withschema "public" already exists, delete that line.
Then restore, stopping at the first error:
psql "$WOWSQL_DB_URL" \
--single-transaction \
--variable ON_ERROR_STOP=1 \
--file=public.sql
With --single-transaction, a failed restore leaves nothing behind. Fix the reported line and rerun.
Check the result
-- Row counts to compare against Supabase
select relname, n_live_tup
from pg_stat_user_tables
where schemaname = 'public'
order by relname;
-- Tables in public that do NOT have RLS enabled
select c.relname
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public' and c.relkind = 'r' and not c.relrowsecurity;
Then call the REST API with the anon key (GET https://your-project-slug.wowsqlconnect.com/rest/v1/<table> with an apikey header). Every table in public gets an endpoint at /rest/v1/<table>. Because we dumped with --no-privileges, check that the anon and authenticated roles can reach your tables. If you see permission errors rather than empty results, the grants are missing. WoWSQL's docs don't say which default grants a table restored over the direct connection gets, so ask support before you grant broadly. With RLS on and no policy, empty results are expected.
If you manage schema changes as migration files, the WoWSQL CLI (pip install wowsql-cli) has wowsql migration new, up, down, and status (CLI migrations), and wowsql gen typescript generates types from the schema (type generation).
Step 4: Move auth users
What Supabase stores: users in auth.users and auth.identities. Passwords are bcrypt hashes in auth.users.encrypted_password (Supabase password security). You can export users with select * from auth.users in the SQL editor (Supabase user management).
What WoWSQL documents: sign-up, sign-in, password reset, magic links, email or phone OTP, OAuth with 19 working providers, TOTP two-factor, and anonymous sign-in when enabled (auth docs). It does not document an admin import endpoint or a way to load password hashes. If keeping existing passwords matters to you, email support@wowsql.com before you plan around it.
That leaves two practical options:
- OAuth users (Google, GitHub, Apple and so on): configure the same provider in Auth → Providers with your client ID and secret, and add the WoWSQL redirect URI (
https://<slug>.wowsqlconnect.com/auth/v1/oauth/<provider>/callback) in the provider console. Users sign in once more and get a WoWSQL account. Their new ID is different from the Supabase one. - Password users, self-serve: users create their account again with
auth.signUp, or you send them through a sign-up or OTP flow. Sessions never carry over. Supabase tokens are signed with Supabase's JWT secret, so everyone signs in once on WoWSQL whichever option you pick.
Re-map row ownership
Because user IDs change, rows that stored the Supabase user_id need the new ID. A pattern that works with documented calls plus plain SQL:
-- Private schema: not under public, so it gets no REST endpoint
create schema if not exists migration;
create table migration.legacy_users (
old_id uuid primary key,
email text not null,
new_id uuid
);
-- Load it from your Supabase export: select id, email from auth.users;
When a user signs in to WoWSQL for the first time, a server route verifies their access token and records the new ID:
import { ProjectAuthClient } from '@wowsql/sdk'
import pg from 'pg' // node-postgres, using the WoWSQL direct connection string
const auth = new ProjectAuthClient({
projectUrl: 'your-project-slug',
apiKey: process.env.WOWSQL_ANON_KEY!,
})
const db = new pg.Pool({ connectionString: process.env.WOWSQL_DB_URL })
export async function claimLegacyRows(accessToken: string) {
const user = await auth.getUser(accessToken) // GET /auth/v1/me
await db.query(
`update migration.legacy_users set new_id = $1
where lower(email) = lower($2) and new_id is null`,
[user.id, user.email],
)
await db.query(
`update public.todos t set user_id = m.new_id
from migration.legacy_users m
where t.user_id = m.old_id and m.new_id = $1`,
[user.id],
)
}
Repeat the second update for each table that has a user_id. Take the user's identity from the verified token, never from a field the client sends. Only match by email if you trust that the user has verified their address on WoWSQL.
The Supabase "create a profiles row on sign-up" trigger lives on auth.users, so it won't come across in a public dump. Create the profile row from your app right after signUp succeeds instead. The response includes the new user.id.
For the full WoWSQL auth flow, including OAuth callbacks and 2FA, see how to add login to your app and our auth-as-a-service comparison.
Step 5: Copy storage files
WoWSQL storage has public and private buckets. Files in a public bucket are served at https://your-project-slug.wowsqlconnect.com/storage/v1/object/public/{bucket}/{path}. Private files are downloaded with an API key. The SDK's upload accepts a Blob, which is what Supabase's download returns, so a copy script is short. Run it on a machine you trust, because it uses both service keys:
import { createClient } from '@supabase/supabase-js'
import { WowSQLStorage } from '@wowsql/sdk'
const supabase = createClient(process.env.SUPABASE_URL, process.env.SUPABASE_SERVICE_ROLE_KEY)
const wow = new WowSQLStorage({
projectUrl: 'your-project-slug',
apiKey: process.env.WOWSQL_SERVICE_KEY, // server only
})
async function copyFolder(bucket, prefix = '') {
const { data, error } = await supabase.storage.from(bucket).list(prefix, { limit: 1000 })
if (error) throw error
for (const item of data) {
const path = prefix ? `${prefix}/${item.name}` : item.name
if (item.id === null) { await copyFolder(bucket, path); continue } // a folder
const { data: blob, error: dlError } = await supabase.storage.from(bucket).download(path)
if (dlError) throw dlError
await wow.upload(bucket, blob, path, item.name)
console.log('copied', `${bucket}/${path}`)
}
}
const { data: buckets, error } = await supabase.storage.listBuckets()
if (error) throw error
for (const b of buckets) {
await wow.createBucket(b.name, { public: b.public })
await copyFolder(b.name)
}
Notes on this script:
listreturns up tolimititems. For folders with more than 1,000 files, add anoffsetloop. Supabase documentslistanddownload.- If you stored full public URLs in your tables, rewrite them after the copy:
update public.profiles
set avatar_url = replace(
avatar_url,
'https://OLD_REF.supabase.co/storage/v1/object/public/',
'https://your-project-slug.wowsqlconnect.com/storage/v1/object/public/')
where avatar_url like 'https://OLD_REF.supabase.co/storage/v1/object/public/%';
- Signed URLs: if your app used Supabase
createSignedUrlfor private files, there is no WoWSQL equivalent. The storage docs say the old presigned-URL routes return 410. Serve those files through a server route that downloads with your key and checks the user first, or move openly shared files to a public bucket.
Step 6: Swap supabase-js for @wowsql/sdk
Install the SDK. The docs pin 3.10.0:
npm install @wowsql/sdk@3.10.0
Most calls map one to one. These are the methods in the 3.10.0 docs and type definitions:
| supabase-js | @wowsql/sdk 3.10.0 |
|---|---|
createClient(url, anonKey) |
new WowSQLClient({ projectUrl, apiKey }), plus new ProjectAuthClient(...) and new WowSQLStorage(...) |
supabase.from('todos').select('*') |
client.table('todos').select('*').get() |
.eq('done', false), .order(...), .limit(...) |
.eq('done', false), .order('created_at', 'desc'), .limit(20), then .get() |
.insert({...}) |
client.table('todos').create({...}) |
.update({...}).eq('id', id) |
client.table('todos').update(id, {...}) |
.delete().eq('id', id) |
client.table('todos').delete(id) |
auth.signUp({ email, password }) |
auth.signUp({ email, password, full_name }) |
auth.signInWithPassword(...) |
auth.signIn({ email, password }) |
auth.signInWithOtp(...) |
auth.sendOtp(...) + auth.verifyOtp(...), or auth.sendMagicLink(email, 'login') |
auth.signInWithOAuth({ provider }) |
auth.getOAuthAuthorizationUrl('google', redirectUri) |
auth.resetPasswordForEmail(email) |
auth.forgotPassword(email) then auth.resetPassword(token, newPassword) |
auth.getUser() / auth.signOut() |
auth.getUser() / auth.logout() |
storage.from(b).upload(path, file) |
storage.upload(b, file, path) |
storage.from(b).getPublicUrl(path) |
storage.getPublicUrl(b, path) |
storage.from(b).createSignedUrl(...) |
Not available (see Step 5) |
supabase.channel(...).on('postgres_changes', ...) |
client.realtime.channel(...).on('postgres_changes', ...) after enabling the table |
A side-by-side example:
// Before (Supabase)
// const { data } = await supabase.from('todos').select('*').eq('done', false)
// After (WoWSQL)
import WowSQLClient, { ProjectAuthClient } from '@wowsql/sdk'
const client = new WowSQLClient({ projectUrl: 'your-project-slug', apiKey: 'wowsql_anon_your_key_here' })
const auth = new ProjectAuthClient({ projectUrl: 'your-project-slug', apiKey: 'wowsql_anon_your_key_here' })
const login = await auth.signIn({ email: 'user@example.com', password: 'SecurePassword123' })
const open = await client.table('todos').select('*').eq('done', false).get()
Three differences catch people out:
- Queries as the signed-in user.
supabase-jsattaches the user's JWT automatically after sign-in.WowSQLClientsends the API key you give it. For queries that should run under RLS as the user, send the anon key inapikeyand the user's access token inAuthorization, as the SDK connection guide documents:
const res = await fetch('https://your-project-slug.wowsqlconnect.com/rest/v1/todos?select=*', {
headers: {
apikey: 'wowsql_anon_your_key_here',
Authorization: `Bearer ${login.session?.accessToken}`,
},
})
- Session events. There is no
onAuthStateChangein 3.10.0. Store the session yourself and useauth.getSession(),auth.setSession({ accessToken, refreshToken }), andauth.refreshSession(). Tokens last for the project's JWT expiry, which defaults to 24 hours. - RPC and embedded selects. We found no
rpc()helper in the 3.10.0 SDK. If you call Postgres functions or useselect('*, profiles(*)')-style joins, test them against the REST API on a scratch project, or move that logic into a view.
Realtime needs one extra call per table before change events flow: POST /realtime/v1/enable with {"schema_name":"public","table_name":"messages"} (realtime docs). Broadcast and presence don't need it. More detail is in Postgres realtime subscriptions. If your frontend is React, the React backend-as-a-service guide shows the same SDK in components.
Step 7: Cut over
- Freeze writes on Supabase, or put the app in maintenance mode.
- Run a final
pg_dumpand restore it into a fresh WoWSQL project, or truncate and reload. Re-run the storage copy for files changed since the trial. - Check counts and policies with the SQL in Step 3. Sign in as two test users and confirm each sees only their own rows.
- Switch environment variables in your app to the WoWSQL project URL and anon key. Keep the service key on the server only.
- Update OAuth redirect URIs in every provider console.
- Watch errors for a few days. Keep the Supabase project, paused or read-only, until you are sure. You can't recover data from it after you delete it.
- Set up backups. Pro and Scale include daily backups kept 7 days, restored through support. That isn't point-in-time recovery. On Free, schedule your own
pg_dump.
Supabase vs WoWSQL after the move: an honest comparison
Supabase facts were checked on its own pages on 21 November 2026 (as of Nov 2026). Links are under the table.
| Supabase | WoWSQL | |
|---|---|---|
| Free plan | $0, 2 active projects, 500 MB database, 50,000 MAU, 1 GB files. Paused after 1 week of inactivity. | $0, 1 project, 256 MB database, 512 MB files, 10,000 MAU. Read-only when over a limit. |
| Entry paid plan | Pro from $25/month, plus compute per project ($10 of compute credits included) | Pro $25/month, dedicated Postgres, 10 GB database, 100,000 MAU |
| Backups | Pro: daily, kept 7 days. PITR add-on $100/month per 7 days of retention. | Pro and Scale: daily, kept 7 days. No PITR. Free has none. |
| Regions | 17 specific AWS regions, including London, Frankfurt, Mumbai, and us-east-1 |
3: Mumbai, US East, Frankfurt |
| Password-hash import | Documented (bcrypt and Argon2 hashes through the admin API) | Not documented; contact support |
| Signed URLs for private files | Yes | No |
| Branching | Pro and above, billed per branch-hour | Not offered |
| Compliance | SOC 2 and ISO 27001 listed on Team ($599/month) | No certifications claimed |
| Hosted MCP server | mcp.supabase.com/mcp |
mcp.wowsql.com/mcp, with project_ref and read_only options |
| Self-hosting | Yes (Docker) | Yes, Apache-2.0, Docker Compose, one admin user and one project |
Sources: Supabase pricing, Supabase regions, Supabase migrate-from-Auth0 guide (hash import), WoWSQL pricing, WoWSQL backups, WoWSQL regions API.
Where Supabase is clearly better: more regions, PITR, branching, password-hash import, signed URLs, compliance reports on its Team plan, and a much bigger ecosystem. Where WoWSQL is a fit: flat plan pricing with a dedicated Postgres instance from Pro, the three regions above, and an Apache-2.0 self-hosted edition. For a broader view, see best Supabase alternatives. If you are building with AI coding tools, the backend for vibe coding guide covers MCP setup after the move.
FAQ
How do I migrate from Supabase to another Postgres database?
Use pg_dump on Supabase's direct connection string, scoped to --schema=public with --no-owner --no-privileges, then restore with psql --single-transaction -v ON_ERROR_STOP=1 into the new database. Auth users, storage files, and Edge Functions need separate steps, because they live outside the public schema.
Can I move Supabase auth users to WoWSQL with their passwords?
Not with a documented tool. WoWSQL's docs have no user or password-hash import, so users sign up again, reset their password, or sign in with the same OAuth provider. Their user IDs change, so re-map user_id columns. Ask support@wowsql.com if keeping passwords is a requirement.
Will my Row Level Security policies still work after migrating?
Policies on public tables come across in the dump, and WoWSQL's docs use auth.uid() in policies the same way. Test any other auth.* helper functions you use. Policies on storage.objects don't come across, because WoWSQL's managed storage docs describe bucket-level public or private access.
How do I export my Supabase storage files?
List each bucket with supabase.storage.from(bucket).list(), download each file with download(), and upload it to WoWSQL with WowSQLStorage.upload(bucket, blob, path, name). Then rewrite any stored public URLs with an SQL replace().
Is there downtime when moving off Supabase?
Plan for a short write freeze while you take the final dump and switch environment variables. Every user signs in again on WoWSQL, because Supabase sessions are signed with Supabase's JWT secret.
What doesn't transfer from Supabase to WoWSQL?
Sessions, password hashes (unless support confirms an option), signed URLs, Edge Functions, Vault secrets, GraphQL calls, branching, and PITR. Extensions such as pg_cron or vector need a paid WoWSQL plan and must be available on the server. Check your dashboard.
Related guides
- WoWSQL vs Supabase (2026)
- WoWSQL vs Neon
- Self-hosted Supabase alternatives
- What is Row Level Security?
- Instant REST API for Postgres
- Firebase to Postgres migration
- Auth as a service compared
- React backend as a service
- Backend for vibe coding
Try the move on a free project first: create a free WoWSQL project · Pricing · Docs