In short
- Crissy Field identified 159,041 Lovable projects in Common Crawl data from December 2025 to September 2026. 34,545 of them used Supabase, and 24,664 websites sent database records to the browser as soon as they loaded.
- Records containing email addresses turned up in 10,560 tables across 7,403 of those 24,664 websites, 30%. The authors say this is not a confirmed leak rate: some addresses are public contacts, and records without an email were not counted.
- The cases they describe are serious: more than 80,000 forum profiles and 200,000 chat messages, more than 1,000 records with passport numbers, and 280,000 emails sent to one provider's customers.
- This is not a breach of Lovable. Each app reads its database from the browser with a public key, so the app's own grants and row level security policies decide what a stranger gets.
- The scan only looked at what a visitor gets without an account. It says nothing about what a second signed-up user can read, which you should test too.
On this page
- What happened, in short
- The numbers, and what each one means
- What kind of data was readable
- Why this keeps happening in apps built with Lovable
- How to check your own Lovable app in ten minutes
- The fix, with a prompt for Lovable
- If your app exposed personal data
- What this scan does not tell you
- Questions
- Sources
What happened, in short
Crissy Field is a security firm in Hamburg that does penetration tests and source code reviews. In early November 2026 it published a report on apps built with Lovable. Using Common Crawl, an open archive of the web, it identified 159,041 Lovable projects from December 2025 to September 2026 and looked at one question: can personal or confidential data be read without logging in? Its answer: yes, in many cases. The German business daily Handelsblatt reported on the research on 2 November 2026, and the firm's own page gives updated figures.
Calling this a Lovable data leak is a shortcut. Nobody broke into Lovable, and no Lovable system gave the data away. Each project is its own app, with its own database, and the exposed records sat in those databases. The firm looked only at projects connected to Supabase and did not examine Lovable's own database features. The report says Handelsblatt put the findings to Lovable; it does not include Lovable's answer, so this page does not quote one.
The numbers, and what each one means
Coverage of the report repeats four figures. They count four different things, and only the last one says anything about personal data.
| Figure | What it counts | What it does not mean |
|---|---|---|
| 159,041 | Lovable projects identified in Common Crawl data from December 2025 to September 2026 | All Lovable apps. The authors write that their sample is not representative of all Lovable applications |
| 34,545 | The projects among them that used Supabase | Apps on other backends were not examined, and neither were Lovable's own database features |
| 24,664 | Websites that sent database records from Supabase as soon as they loaded, with no login and no click | A leak. The report says this alone is not a security issue: a public catalogue, a menu or a blog is meant to load this way |
| 7,403 (30% of 24,664) | Websites where records containing email addresses were found, in 10,560 tables, after further read-only requests with the same API key | A leak rate. Some addresses are public contacts, and personal records without an email address were missed |
The 30% figure should therefore not be read as a confirmed data leak rate.
So the honest reading is narrower than some headlines. Nobody knows what share of Lovable apps expose personal data. What the report establishes is that the problem is easy to find at scale: thousands of websites handed over tables containing email addresses to a visitor who never logged in, and some of those tables held far worse than email addresses.
What kind of data was readable
The report describes its findings by category, without naming anyone. Among them:
- A German lifestyle forum: more than 80,000 profiles with full names, email addresses, dates of birth and gender, and more than 200,000 chat messages.
- Ticket and food sales: tens of thousands of records, with email addresses, phone numbers, postal addresses, payment information and ticket codes among the records inspected.
- A service provider: more than 1,000 records containing identity document details, including passport numbers, expiration dates and nationalities.
- A property management company: AI-generated summaries of internal emails, with sensitive information about tenants, owners and business partners.
- One provider's outbox: 280,000 emails sent to its customers.
- Elsewhere: tens of thousands of contracts, invoices, personal photo albums and internal WhatsApp communications, plus newsletter subscriptions, waiting lists and support inquiries.
The authors point out what such data is good for in the wrong hands: phishing, ticket fraud, identity theft. None of these projects looks like a hobby page. They are small businesses that built a real tool quickly, put real customers in it, and never saw the database from the outside.
Why this keeps happening in apps built with Lovable
The report does not go into the mechanism; it speaks of access control mistakes. The mechanism is documented by Lovable and Supabase themselves. A Lovable app's frontend talks to its database directly, from the visitor's browser, using a project URL and a public key that are built into the JavaScript. Both are meant to be public. What a visitor can read is decided inside the database, by the privileges of the anon role and by row level security (RLS) policies on each table. A table with RLS off, or with a policy whose condition is true, answers anyone who asks. The Supabase anon key guide explains why hiding the key is not the fix.
The app gives no sign of it. Every screen shows the right data to the right user, because the screens only ask for the right rows. The database would have answered a broader question too, and nobody asked it until a stranger did.
The report adds the point that turns one mistake into thousands: generated apps look alike. In its words, database integrations follow recurring patterns, which makes it easier for attackers to look for similar misconfigurations, and an approach that works against one app may work against many others with little extra effort. It also says, fairly, that access control mistakes can happen in any application, whether written by people or built with AI.
None of this is new. In 2025, CVE-2025-48757 was assigned after researchers found 170 of 1,645 showcased Lovable apps, about one in ten, with missing or weak RLS. Lovable disputes that CVE on the grounds that each customer is responsible for protecting their own app's data, and the new report notes that Lovable's terms place responsibility for applications and data handling on its customers. Lovable has since built real tooling: a Quick scan that runs when you publish and checks your database rules, and a Deep scan that reads your code. Both are static analysis, as our Lovable security page details: they read settings and code, and neither sends a request to your published app to see what comes back.
How to check your own Lovable app in ten minutes
You can run on your own app the two things the researchers did, plus the checks they could not do from outside. Nothing here changes your data.
- 1
Watch what loads before anyone logs in
Open your published app in a private window, signed out. Open the browser's developer tools, go to the Network tab, type
rest/v1in the filter and reload. Each line is a table your app hands to every visitor. Click one and read the response: is every field in it meant for the public? - 2
List the tables with RLS off
In Lovable, open More → Database → Manage → SQL editor and run the first query below. Every row is a table that RLS does not protect at all.
- 3
Find the policies that let everyone through
Run the second query. A
selectpolicy with the conditiontrueis right for a table of public posts and wrong for profiles, orders or messages. Then read the policies forauthenticated: one that never compares a column toauth.uid()passes for any stranger who signs up. - 4
Ask for a table the way a stranger would
Take the URL and the public key from your app's
.env(VITE_SUPABASE_URLandVITE_SUPABASE_PUBLISHABLE_KEY) and run the command below against a table that holds user data. A row in the answer means anyone on the internet can read that table. - 5
Sign up as a second user
Create a second account with another email address and look for the first account's data: open its record by id, list its orders, read its messages. The scan in the report never logged in, so it could not see this, and it is the most common access bug we find in generated apps. The IDOR guide shows the test step by step.
- 6
Open your storage as a visitor
Copy the address of an uploaded file, sign out and paste it in a private window. If an invoice or an ID scan opens, the bucket is public. See Supabase storage security.
-- 1. Tables with RLS off, and whether the public key may read them
select c.relname as table_name,
has_table_privilege('anon', c.oid, 'select') as anon_can_read
from pg_class c
join pg_namespace n on n.oid = c.relnamespace
where n.nspname = 'public'
and c.relkind in ('r', 'p')
and not c.relrowsecurity;
-- 2. Policies that let every caller through
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public'
and (qual = 'true' or with_check = 'true');curl "https://YOUR_PROJECT_REF.supabase.co/rest/v1/profiles?select=*&limit=1" \
-H "apikey: YOUR_PUBLISHABLE_KEY"profiles with one of your tables. An empty array means the policies filtered every row out, or the table is empty.The fix, with a prompt for Lovable
Lovable writes policies through its chat, so a precise prompt is the fastest route. Paste it, then reopen More → Database → Manage → Policies and read what changed.
Enable row level security on every table in the public schema. For each table that stores user data, add policies so a signed-in user can only read, insert, update and delete rows where user_id equals auth.uid(). Add no policy for the anon role unless I name the table. Then list every policy you created or changed.-- Leaks: every visitor reads every profile
create policy "Profiles are viewable" on public.profiles
for select using (true);
-- Leaks too: any stranger who signs up reads every profile
create policy "Signed-in users can view profiles" on public.profiles
for select to authenticated using (true);
-- Fixed: each user reads only their own row
create policy "Users view their own profile" on public.profiles
for select to authenticated using ((select auth.uid()) = user_id);Two things do not fix it. Rotating the public key changes nothing, because the new one ships in your next build and reaches the same tables. And removing a table's name from your code hides nothing either: the name is in builds that browsers and archives already hold.
If your app exposed personal data
Closing the table is the first step, not the last. If you are in the European Union or serve people there, personal data that was readable by anyone may be a personal data breach under the GDPR, whose definition includes unauthorised disclosure of, or access to, personal data. Article 33 asks the controller, which for your app is you, to notify the supervisory authority without undue delay and, where feasible, within 72 hours of becoming aware of it, unless the breach is unlikely to result in a risk to the people concerned. Article 34 adds that you tell those people directly when the risk to them is high. Passport numbers and private messages sit at that end of the scale.
- Fix the access rule, and confirm from outside that the table no longer answers.
- Write down what was exposed: which tables, which fields, how many people, and since when (the date of the migration or the publish that opened it).
- Read your backend's API logs as far back as they go, and look for requests to that table that did not come from your app's pages.
- Decide on the notification with those facts in hand, and keep a record of the decision either way. This page is not legal advice: for sensitive data, ask a lawyer or your data protection authority.
- Rotate any secret that sat in an exposed table, such as API keys or tokens stored in rows. API key leaked: what to do gives the order.
What this scan does not tell you
The report measured one thing: what an anonymous visitor could read, on a sample of Supabase-backed projects, using email addresses as the sign of personal data. That leaves out most of what goes wrong in a live app. It did not test writing, so it says nothing about tables a stranger can change or empty. It did not log in, so it says nothing about one customer reading another's rows. It did not look at edge functions, where an AI route that answers anyone costs money instead of data, or at secret keys shipped in the bundle.
Its advice to builders is short and right: before an app handles confidential data, have its access permissions, its interfaces and the separation between user accounts reviewed, and repeat the review after significant changes. It also says that automated checks are no substitute for a professional security assessment. We build an automated test and we agree with the limit: a script cannot judge your business rules. What it can do is ask the narrow question the researchers asked, on every deploy, with the request that worked as proof. What an automated pentest can and cannot prove draws that line in detail.
Questions
Was Lovable hacked?
No. The November 2026 report is about apps built with Lovable, not about Lovable's own systems. The exposed records sat in each app's own Supabase database, where the app's access rules let visitors read them. The researchers examined 159,041 projects and name none of them.
How many Lovable apps leak data?
Nobody knows. In the report, records containing email addresses were found on 7,403 of the 24,664 websites examined closely, 30%, and the authors say this should not be read as a confirmed leak rate. An earlier study behind CVE-2025-48757 found missing or weak row level security in 170 of 1,645 showcased apps, about one in ten.
How do I know if my Lovable app is affected?
Open the published app signed out, filter the browser's Network tab on rest/v1 and read what loads. Then run a query in the SQL editor that lists tables with RLS off, and request one table with your public key from a terminal. If a row of user data comes back, anyone can read that table.
Does Lovable's security scan catch an open table?
The Quick scan runs when you publish and checks database rules, including tables without RLS and rules that let everyone through. It reports and does not block by default, and it is static analysis: it reads settings and does not request your live app. A policy that looks reasonable and still lets a second user read everything needs a test from outside.
Who is responsible when a Lovable app exposes data?
The app's owner. The report notes that Lovable's terms place responsibility for applications and data handling on its customers, and Lovable disputes CVE-2025-48757 on the same grounds. Under the GDPR, the business that runs the app is the controller of its users' data.
Should I rotate my Supabase key after this?
Not the public one. The publishable or anon key is meant to be public, and a new one reaches the same tables. Fix the policies instead. Rotate secrets only if a secret key was exposed, for example a service role key in your frontend or API keys stored in a readable table.
Sources
- 1.Lovable: research on 159,041 projects, Crissy Field
- 2.Control who can access your app's data, Lovable Documentation
- 3.Security overview, Lovable Documentation
- 4.Row Level Security, Supabase Docs
- 5.CVE-2025-48757, NVD
- 6.Statement on CVE-2025-48757, Matt Palmer
- 7.General Data Protection Regulation, Articles 4, 33 and 34, EUR-Lex