Lovable Supabase Data Exposure: 24,664 Apps and How to Check Yours
Lovable Supabase Data Exposure: 24,664 Apps and How to Check Yours
A Lovable app can look finished and still give away its database to anyone who opens it. That's the uncomfortable takeaway from new research on the Lovable Supabase data exposure problem, which climbed Hacker News this weekend.
Crissy Field, a German firm, scanned 159,041 Lovable projects. Of the 34,545 that use Supabase, 24,664 sent database records to the browser on page load, with no login needed.
If you've shipped anything on Lovable, here's what the research says and what's probably going on under the hood. You'll also see why Supabase's new 30 October default won't save older apps, and how to test your own today.
What the research found on Lovable Supabase data exposure
The numbers come straight from the researchers' write-up, which updates a Handelsblatt investigation from 2 November. The projects were sampled between December 2025 and September 2026, so this isn't a fresh weekend scan. It's a long look at how vibe-coded apps hold up in the wild.
- 159,041 Lovable projects found through Common Crawl
- 34,545 of them use Supabase as the backend
- 24,664 returned database records on page load, with no login or other interaction
- Email addresses showed up in 10,560 tables across 7,403 sites, about 30% of the sites that returned data
The authors are careful about that 30%. They say it isn't a confirmed leak rate, and they note their sample isn't representative of every Lovable app.
The examples are what make this a big deal. A German lifestyle forum exposed more than 80,000 profiles and over 200,000 chat messages. A service provider had more than 1,000 ID-document records with passport numbers.
Another app exposed 280,000 emails it had sent to its customers. There were also ticket and food sales records, contracts, invoices, photo albums and internal WhatsApp messages.
Lovable hasn't publicly responded to the report.
Technical breakdown: Supabase RLS in Lovable apps
The researchers didn't publish the exact access details, and they never name a specific misconfiguration. So treat what follows as the likely mechanism, not their finding.
Every Supabase frontend ships a publishable (anon) key to the browser. That's by design. Supabase's own API key docs call it safe to expose online and say anyone can read it, so it only reaches what Row Level Security allows.
That last part is the whole story. Row Level Security (RLS) is a Postgres feature that decides which rows a given user can see. Supabase's RLS guide tells you to enable it on every table in an exposed schema.
Once it's on, the publishable key can't read anything until you write policies. If it's off, or the policies are too loose, that public key can read every row the policies let through.
The researchers' own method fits that picture. They checked what loaded on the page, then made extra read-only requests with the same API key the page itself used.
No hacking tools. Just the app's own credentials.
The default change most coverage misses
Supabase changed its defaults this year. A changelog entry from 28 April 2026 says new tables are no longer exposed to the Data API automatically. That kicked in on 30 May for new projects and on 30 October 2026 for all existing ones.
Sounds like a fix. It isn't, for most of the apps in this study. Tables that already had grants stay reachable, and every project in the sample was collected before 30 October.
If your Lovable app has been live for a while, the new default probably doesn't protect you.
One more gotcha. Supabase's dashboard Table Editor turns RLS on for new tables, but plain Postgres doesn't. Tables created by migrations or raw SQL deserve a second look.
How to run a Lovable security check on your own app
Only test apps you own. Probing someone else's database is a fast way to get a lawyer's letter.
1. Find tables with RLS turned off. Open the Supabase SQL editor for your project and run:
select schemaname, tablename
from pg_tables
where schemaname = 'public'
and rowsecurity = false;
Any row in that result is a table with no row-level protection. Next, see which tables the public anon role can still touch, since the new default doesn't remove existing grants:
select tablename
from pg_tables
where schemaname = 'public'
and has_table_privilege('anon', format('%I.%I', schemaname, tablename), 'SELECT');
A table that shows up in both lists is your top priority.
2. Test it like a stranger would. Open your live app in a private window without logging in. In dev tools, look at the network requests to *.supabase.co and copy the apikey header. Then:
curl "https://YOUR-PROJECT.supabase.co/rest/v1/YOUR_TABLE?select=*&limit=5" \
-H "apikey: YOUR_PUBLISHABLE_KEY"
If you get real rows back for a table holding user data, anyone can do the same.
3. Lock it down. Enable RLS and add an owner-only policy. This is Supabase's documented pattern:
alter table public.todos enable row level security;
create policy "Individuals can view their own todos."
on todos for select to authenticated
using ( (select auth.uid()) = user_id );
Swap in your table and owner column. You'll need separate policies for insert, update and delete.
4. Check your keys. The secret or service_role key bypasses RLS entirely. If it's anywhere in frontend code, rotate it now.
What Lovable changed on 12 November
Lovable's changelog from 12 November adds a gate before publishing. Projects on its built-in backend with unresolved critical security findings now have publishing paused until you review them. You can ask Lovable to fix them all in one request, which uses one of your free fixes.
The entry doesn't mention Supabase, RLS or the research. It's a good step. But it's an automated scan, and the researchers' own advice is to treat automated scans as an addition to a professional review, not a replacement.
Real-world use cases: who should care most
- Founders with paying users. If there's any chance your Lovable app is exposing user data like emails, orders or messages, step 2 above takes minutes and tells you whether you've got a problem.
- Agencies shipping client apps. One forgotten table can expose a client's whole customer list. Add the SQL check to your handoff checklist.
- Teams handling IDs or payments. Passport numbers turned up in this study. If you collect anything like that, get a human security review before launch.
Hard limitations and flaws
The research has gaps worth naming. There's no publication date on the page.
Access details aren't published, so nobody can independently reproduce the exact counts. And the authors say the 30% email figure isn't a confirmed leak rate.
The fix has limits too. RLS policies are code, and code has bugs. A policy that checks the wrong column is as bad as no policy.
Lovable's new pre-publish check only covers projects on its built-in backend, and its changelog doesn't say what counts as critical.
And this isn't new for Lovable. A 2025 vulnerability, CVE-2025-48757, covered insufficient RLS in Lovable-generated sites that let unauthenticated users read or write database tables. The pattern keeps coming back because the AI writes the frontend fast and the access rules are easy to skip.
Verdict: your developer action plan
This probably isn't one bug. Lovable made it very easy to ship a database without guardrails, and thousands of people did.
If you've built on Lovable with Supabase, do this today:
- Run the RLS query and fix every table it lists.
- Curl your own tables with the publishable key from a logged-out browser.
- Write owner-scoped policies for select, insert, update and delete.
- Keep the
service_rolekey off the client. - Re-check after every big change, and get a real security review before you handle IDs or payments.
Vibe coding gets you to launch. It won't stop a vibe coded app data leak. It doesn't get you to safe. That part's still on you.
Tools in this post
Written by
Co-founder of Tool Directory AI. Tests and reviews the AI tools listed here.


