Thousands of apps built with Lovable, the AI app builder, left their databases readable by anyone on the internet. Researchers found passport numbers, expiry dates, and nationalities in more than 1,000 records at one service provider, plus a forum that exposed over 80,000 user profiles and more than 200,000 chat messages. Nobody had to log in, and nobody had to hack anything. The data was simply sent to the browser on page load.
If you built an app with Lovable, here is the 60-second check: open your app in a browser, press F12 to open DevTools, go to the Network tab, reload the page, and look for requests to a Supabase REST endpoint. If the response contains rows that belong to other users, your app leaks.
The fix is to turn on Row Level Security in Supabase and write policies that limit each user to their own rows. This guide walks through the findings, the cause, the check, and the fix.
What the Researchers Found
German security firm Crissy Field, working with newspaper Handelsblatt, published its report on November 14, 2026. The team examined 159,041 projects built on Lovable, found in Common Crawl data covering December 2025 to September 2026. Its findings are uncomfortable for anyone who shipped a Lovable app without touching the database settings.
Of the 159,041 projects, 34,545 used Supabase as their database. The researchers then looked closer at those, and 24,664 of them sent database records to the browser on page load, with no login and no interaction required. Anyone who visited the page received the data along with it. The researchers sent only read-only requests using the public anon key that every frontend already ships, and they did not download full datasets.
| Figure | Number | What it means |
|---|---|---|
| Lovable projects examined | 159,041 | Found in Common Crawl data, December 2025 to September 2026 |
| Projects using Supabase | 34,545 | Apps with a Supabase database behind them |
| Apps sending records to the browser | 24,664 | Data arrived on page load, with no login or interaction |
| Tables containing email addresses | 10,560 tables across 7,403 sites | About 30% of the sites examined further |
| Identity-document records at one provider | More than 1,000 | Passport numbers, expiry dates, and nationalities |
| User profiles exposed on one forum | More than 80,000 | Names, emails, birth dates, and gender |
| Chat messages exposed on the same forum | More than 200,000 | Private messages readable by any visitor |
Read the email figure carefully. Email addresses turned up in 10,560 tables across 7,403 of the 24,664 sites, which is about 30% of the sites examined further. The researchers themselves say this is NOT a confirmed leak rate. An email address sitting in a table does not prove it was exposed to visitors, and the researchers did not claim otherwise. The confirmed cases are the ones above: the identity-document records, the forum profiles, and the chat messages.
Two things the researchers did not find are just as important. They could not establish whether any exposed data was actually misused, because that would require tracking down whoever might have read it. And Lovable's own newer database features, introduced late in 2025, were NOT examined, so this report says nothing about apps built with those features.
The story hit the Hacker News front page on November 14–15, 2026, with around 750 points and about 298 comments. That is a large audience for a security report. The Frontier Now summary of the Crissy Field report is a good place to read the findings in full.
Why It Happened: RLS Off by Default
The cause is not a bug in Lovable, and it is not a bug in Supabase. It is a default setting combined with a misunderstanding that AI-built apps made widespread. Supabase ships with Row Level Security, or RLS, disabled by default on new tables. Until you turn it on and write policies, anyone with the project's public anon key can read every row in the table.
Here is the part most people get wrong: the anon key is meant to be public. It ships inside every frontend that talks to Supabase, and it is visible to anyone who opens DevTools. Supabase designed it that way on purpose. The key identifies the project; it does not protect the data. RLS is what protects the data, and RLS is the part that was left off.
That is why AI app builders made the problem so common. Lovable generates a working app in minutes, including the database wiring, and a new builder can ship something that looks finished without ever seeing a database setting. The app works, the data loads, and nothing complains. There is no error message for "your database is readable by the whole internet," because from the database's point of view, that is the configuration you asked for.
Lovable's Terms & Conditions put responsibility for data handling on customers. That is the legal position, and it matches how the platform is designed: Lovable builds the app, but the person who ships it owns what the app does with people's data. If you collected personal data through a Lovable app, the responsibility for protecting it was yours, whether or not you knew the setting existed.
This is a familiar pattern in AI-assisted building. The same kind of silent default has bitten people in other tools, like the case where a password ended up in a public GitHub repo because an AI tool wrote it into a file nobody reviewed. The lesson is the same: AI builders move fast, and the safety checks that used to come from a developer reading the code now have to come from you.
How to Check Whether Your Lovable App Leaks
The check takes about a minute, and you do not need to write any code. It works for any Lovable app that uses Supabase, and it tells you exactly what a stranger sees when they visit your app.
First, open your app in a browser and press F12 to open DevTools. Go to the Network tab, then reload the page. Look for requests to a Supabase REST endpoint — the URL will contain supabase.co/rest/v1/ followed by a table name. Click one of those requests and look at the Response tab.
Now ask one question: do the rows in that response belong only to you, or do they include other people's data? If you see names, emails, or messages from users who are not you, your app leaks. If the response is empty or contains only your own rows, that table is protected. Repeat the check for each table your app loads, because one table can be locked down while another is wide open.
There is a second, more thorough check inside Supabase itself. Open your project, go to the Database section, and run the Security Advisor. It flags every table with the warning "RLS Disabled in Public," which is Supabase's way of saying the table is readable by anyone with the anon key. Any table carrying that warning needs policies before the app is safe to use with real people's data.
Test from a logged-out browser window, or an incognito window, so you see what a stranger sees. Testing while logged in as the app owner can hide the problem, because some setups show different data to different roles. If you want to be thorough, test the app the way an attacker would: no account, no login, just the public URL.
This is the same discipline that applies to any app that talks to an API from the browser. As we covered in our guide to how client-side apps can leak data through their APIs, anything the frontend can fetch, a visitor can fetch too. The browser is not a trusted place to hide data.
How to Fix It: Enable RLS and Write Policies
The fix has two parts, and both are required. First, enable RLS on every table. Second, write policies that say who can read and write which rows. Enabling RLS without policies locks everyone out, including your own app, so the policies are what make the app work again — safely this time.
In the Supabase dashboard, open the Database section, pick a table, and turn on RLS. Then add a policy. The most common policy lets a logged-in user see only their own rows, using the auth.uid() function to match the row's owner to the signed-in user:
alter table profiles enable row level security;
create policy "Users can view their own profile"
on profiles for select
using (auth.uid() = user_id);
That short block does the whole job for a personal-data table: RLS is on, and a select query returns a row only when the signed-in user's ID matches the row's user_id. A visitor with no login gets nothing, and a logged-in user gets only their own rows. Write a matching policy for inserts, updates, and deletes on the same table, and repeat the process for every table that holds user data.
Public content needs a different policy, not no policy. If your app has a blog or a public directory, write a policy that allows reads of exactly those rows — for example, only rows marked as published. The point is that every read is a deliberate decision in a policy, not an accident of a missing setting.
Next, check your storage buckets. Files uploaded to Supabase Storage have their own policies, separate from table RLS. A bucket with a public read policy exposes every file in it, including uploads that users assumed were private. Set bucket policies the same way: each user reads only their own files, and anything meant to be public is marked public on purpose.
Finally, never put the service_role key in frontend code. That key bypasses RLS entirely, and it belongs only in server-side code you control. If an AI tool or a tutorial ever pasted it into your app's frontend, remove it immediately and rotate the key in the Supabase dashboard. A leaked service-role key is far worse than missing RLS, because it hands over full database access.
After applying the fix, run the DevTools check again from an incognito window. The Supabase requests should now return only your own rows, or nothing at all when you are logged out. Also re-run the Security Advisor and confirm the "RLS Disabled in Public" warnings are gone. The Supabase Row Level Security docs explain the policy syntax in detail if you need more than the basic pattern above.
What to Do If You Typed Personal Data Into a Lovable-Built App
Maybe you are on the other side of this story: you used an app someone else built with Lovable, and you typed in your name, email, or passport details. The researchers did not publish the names of any affected app, so you cannot check a list. But there are practical steps you can take right now.
First, contact the app owner and ask whether the app used Supabase without RLS, and whether your data was exposed. Be specific: ask which tables held your data and whether they have since enabled RLS. A responsible owner will answer plainly, and your question may be the first time they learn about the problem.
Second, request deletion of your data under GDPR Article 17, the right to erasure, if the app serves users in Europe. You do not need to quote the law at length — a short message asking the owner to delete your account and all associated records is enough. Keep a copy of your request and the date you sent it.
Third, watch for misuse. If your email address was exposed, expect more spam and phishing, and be suspicious of any message that knows details about you. If passport details were involved, contact your passport agency and ask for their guidance on reissue. A passport number on its own is not enough to travel as you, but it is enough for identity fraud attempts, so take the agency's advice seriously.
Fourth, place a fraud alert with your credit bureau or national fraud service if your identity details were exposed. This makes it harder for someone to open accounts in your name, and it costs you nothing but a few minutes. If you reused a password anywhere, change it, and turn on two-factor authentication on the accounts that matter most.
None of this is a reason to panic, but it is a reason to act. The researchers found publicly readable data, not a breach, and they could not establish whether any exposed data was misused. The risk is real but unproven, and the steps above reduce it to the point where you can stop worrying about it.
Safer Lovable Alternatives for Apps That Hold Customer Data
If this report has put you off Lovable, you are not alone — but switching tools is not the fix. Every no-code and AI app builder that connects to a database has the same trap waiting in it: a default that leaves data readable until someone configures access rules. The honest question is not which builder is safe, but which builder makes the safe configuration hard to miss.
When you evaluate Lovable alternatives, ask each one the same three questions. Does it turn on database access rules by default, or do you have to opt in? Does it warn you before you publish an app that reads personal data without restrictions? And does it make the rules visible in the builder, so you can see them without opening a separate database console?
A tool that answers all three well is genuinely safer than one that leaves the settings buried. But no builder can protect data you never told it to protect. Even the most careful of the Lovable alternatives still needs the same RLS discipline: access rules on every table, policies on every storage bucket, and a logged-out test before real users arrive.
The cheapest safety upgrade is not a new tool at all. It is the habit of checking your own app the way a stranger would, every time you ship a feature that touches personal data. That habit transfers to any builder, and it is what the developers behind the exposed apps were missing — not a better platform, but a five-minute check.
If you do switch, migrate the data properly: export it from Supabase, confirm the new tool's access rules are in place before importing, and delete the old project once the move is done. A half-finished migration leaves your data in two places, and the old copy is still readable until you remove it. The Alva Chew write-up of the Lovable leak has more on how the exposed apps were built and why the defaults mattered.
Frequently Asked Questions
What did the Lovable apps data leak expose?
Researchers from Crissy Field examined 159,041 Lovable projects and found 24,664 Supabase-backed apps sending database records to the browser on page load, with no login needed. At one service provider, more than 1,000 records held identity-document details like passport numbers, expiry dates, and nationalities. A German lifestyle forum exposed more than 80,000 user profiles and more than 200,000 chat messages. The researchers did not download full datasets and could not establish whether any exposed data was misused.
Was Lovable hacked?
No. This was not a breach or a hack. The data was publicly readable because Supabase Row Level Security was left disabled on the apps' database tables, so anyone visiting the app received other users' records along with the page. The researchers used only read-only requests with the public anon key that every frontend already ships. No systems were broken into.
How do I check whether my Lovable app leaks data?
Open your app, press F12 for DevTools, go to the Network tab, reload the page, and look for Supabase REST requests. Check whether the responses contain rows belonging to other users. Then run the Supabase Security Advisor, which flags any table with the warning "RLS Disabled in Public". Always test from a logged-out or incognito window, so you see what a stranger sees.
How do I fix a Lovable app that exposes Supabase data?
Enable Row Level Security on every table, then write policies that limit each user to their own rows, usually with auth.uid() matched against the row's user_id. Apply matching policies to storage buckets, and never put the service_role key in frontend code, since it bypasses RLS entirely. After the fix, repeat the DevTools check from an incognito window and confirm the Security Advisor warnings are gone.
Are there safer alternatives to Lovable for apps that hold customer data?
There are Lovable alternatives, but switching tools alone does not fix the problem. Every app builder that connects to a database can leave data readable if access rules are not configured.
When evaluating alternatives, ask whether they enable access rules by default, warn before publishing an app that reads personal data without restrictions, and show the rules inside the builder. Whatever tool you choose, you still need the same discipline: RLS on every table, policies on every bucket, and a logged-out test before real users arrive.
Is my data safe if the app makes me log in?
Not necessarily. A login screen proves nothing about the database behind it. In the exposed apps, data was sent to the browser on page load with no login at all, but even apps with login can leak if RLS is off.
Once you are signed in, the app may fetch every row in the table, including other users' data. The only thing that protects your data is a policy that limits each user to their own rows.
That is also why stories about AI tools and personal data keep recurring, like the reports of human reviewers reading Gmail and Drive — the interface looks private, but the data handling behind it is what matters.