Lovable is safe to use as a tool, but an app built with it is only as safe as its database rules, and many published Lovable apps get those rules wrong. In November 2026, the Hamburg security firm Crissy Field reported that 24,664 Lovable sites using Supabase sent database records to anyone who opened them, and that read-only requests with the same public key reached tables containing email addresses on 7,403 of those sites. The cause is almost always missing or too-open Row Level Security (RLS) in Supabase, which you can check yourself in about 15 minutes.
This guide separates the three different Lovable security stories of 2026, explains why the same mistake keeps appearing, lists what Lovable and Supabase changed (and what those changes do not fix), and gives a step-by-step check with the exact SQL to run. If you are deciding whether to keep building on Lovable or hand the app to a developer, the last sections cover that decision and what a review costs.
What happened: three different Lovable security problems
People search for a "Lovable security breach" as if it were one event. It was three, with different causes and different fixes.
| When | What | Whose problem | Status |
|---|---|---|---|
| May 2025 | CVE-2025-48757: insufficient RLS in generated sites let unauthenticated users read or write database tables | Apps built on Lovable | Lovable disputes the CVE, saying each customer is responsible for protecting their app's data |
| Feb 3 to Apr 20, 2026 | A backend regression let any signed-in Lovable user open the chat history and source code of public projects | Lovable's platform | Fixed within two hours of the public report; public projects made private |
| Sep 16, 2026 | Ascertify scanned 70 public Lovable repositories: 28 (40%) had a critical or high finding in their own code | Apps built on Lovable | Research only; no live systems tested |
| Nov 2 and Nov 14, 2026 | Crissy Field and Handelsblatt: personal data readable without login in Lovable apps on Supabase | Apps built on Lovable | Partly addressed for new tables and new publishes; existing open tables stay open until fixed |
The April incident was Lovable's own mistake, and Lovable published a detailed account of it. The other three are about the apps people build: the code and database rules that end up on the internet. A platform fix does not change those.
What Crissy Field found
Crissy Field took 159,041 Lovable projects from the Common Crawl web archive, published between December 2025 and September 2026. 34,545 of them used Supabase as the database. On 24,664 sites, the page sent Supabase records as soon as it loaded, without a login. That alone can be fine, because a menu or an event list is meant to be public. With further read-only requests using the same public key, the researchers found records containing email addresses in 10,560 tables across 7,403 of those sites (30%).
The researchers are careful about that 30%. An email address can be a public contact or test data, the method misses personal records without an email, and the Common Crawl sample is not representative of all Lovable apps. So it is not a leak rate. The examples are serious anyway: more than 80,000 forum profiles and 200,000 chat messages, ticket and food orders with phone numbers, addresses and payment information, more than 1,000 records with passport numbers, contracts, invoices and internal WhatsApp messages. Crissy Field did not name the apps and could not establish whether anyone misused the data.
What Ascertify found
Ascertify's September scan read code rather than live systems. Of 47 apps with a database it could read, 14 (30%) had a policy that let any signed-in user, or anyone at all, write to some tables. Of 33 apps with edge functions, 19 (58%) exposed one that anyone on the internet could call with no check. 44 of 70 had no tests, and 69 of 70 shipped a dependency with a known vulnerability, mostly build tooling from the template. The median app had zero critical or high findings of its own, so the problems are concentrated in a minority of apps that are wide open.
Why it keeps happening
A Lovable app on Supabase talks to the database straight from the browser. The key it uses (the anon or publishable key) sits in the page's code, where anyone can see it, and that is by design. What stops a stranger from reading other people's rows is Row Level Security: Postgres rules attached to each table that decide which rows each user may see or change. Supabase's documentation says RLS must be enabled on every table in an exposed schema.
When RLS is off, or a policy says using (true) for anonymous users, the public key opens the whole table. The AI that wrote the app may have created a correct policy, a policy that is too broad "to make it work", or none at all. Someone who has never heard of RLS cannot tell the difference, and the app works the same way in a demo either way.
This is not specific to Lovable. In September 2026 UpGuard checked about 300,000 domains with signs of Supabase and found 16,326 databases exposing readable tables, built with all kinds of tools. Lovable apps are easier to find in bulk because they follow the same patterns, which is also what makes them easier to attack at scale.
What Lovable and Supabase changed
| Change | Date | What it does | What it does not do |
|---|---|---|---|
| Supabase: new tables not exposed to the Data API automatically | Applied to all existing projects on October 30, 2026 | A new table in public needs an explicit grant before the browser can query it | Existing tables keep their current grants and stay reachable |
| Lovable: review critical findings before publishing | November 12, 2026 | Projects on Lovable's built-in backend with unresolved critical findings get a review dialog when you click Publish | You can still choose to publish anyway. Only Enterprise workspaces can block publishing with critical issues |
| Lovable: Fix all from the project chat | November 2026 | Sends open critical findings and warnings to Lovable to fix in one request | Does not run on apps nobody opens again |
| Lovable Quick scan | Runs on every publish | Checks database rules (tables without RLS, rules that let everyone through), npm dependencies with known vulnerabilities and an unauthenticated MCP server | Does not review your app's logic. That is the Deep scan, which you have to start yourself |
The pattern is the same in every row: the changes protect new tables and new publishes. An app that leaked on October 29 still leaks today unless someone fixes it. Lovable's own security documentation is explicit about the split of responsibility: "You are responsible for ensuring that your app meets the security requirements appropriate for its use case, especially if it handles sensitive data or performs critical functions." The same page recommends an additional professional security review for apps that handle sensitive data.
Check your Lovable app in 15 minutes
You need access to the Supabase project behind the app (Supabase dashboard, then SQL Editor). Everything below only reads settings; none of it changes your data.
1. Run Lovable's Deep scan
In the project, open More, then Security, and start the Deep security scan. It is free and usually takes 3 to 13 minutes. The Quick scan only runs on publish, and its results go stale as soon as the project changes, so a green result from three months ago means little.
2. Open the Supabase Security Advisor
Supabase dashboard, then Advisors, then Security Advisor. Fix every table it flags, starting with tables that hold personal data. The two findings that matter most here are "RLS disabled in public" and "policy exists but RLS disabled".
3. List tables without RLS
select tablename
from pg_tables
where schemaname = 'public'
and rowsecurity = false;
Every table in this list is readable and writable by anyone who has the public key, if the table has grants for the anon role. The list should be empty.
4. Find policies that let everyone through
select tablename, policyname, cmd, roles, qual, with_check
from pg_policies
where schemaname = 'public'
and (qual = 'true' or with_check = 'true');
A true condition means "every row, for every user in these roles". It is correct for a public menu. It is wrong for orders, messages, profiles or anything with a name, email or payment detail. A safe policy for user data usually compares the row's owner with auth.uid().
5. See what the anonymous role can reach
select table_name, privilege_type
from information_schema.role_table_grants
where table_schema = 'public'
and grantee = 'anon'
order by table_name;
Grants decide whether a role can touch a table at all; RLS decides which rows it sees. If anon has INSERT, UPDATE or DELETE on a table that strangers should never write to, revoke it or make sure a strict policy covers it.
6. Check storage buckets
select id, name, public
from storage.buckets
where public = true;
A public bucket serves every file to anyone with the URL. That fits product photos, not uploaded ID documents, invoices or contracts.
7. Test as a stranger
Open the published app in a private browser window, without logging in. Open the browser's developer tools, go to the Network tab and filter for rest/v1. Click through the app and look at what each response contains. Then search the loaded JavaScript for service_role or sb_secret_: a secret key in the front end gives full access to the database and must be rotated immediately.
8. Check edge functions
Ascertify found open edge functions in 58% of the apps that had them. In supabase/config.toml, any function with verify_jwt = false accepts calls from anyone. That is right for a public webhook that verifies its own signature, and wrong for a function that reads user data or calls a paid AI API on your bill.
What automated scans miss
| Check | Lovable Quick scan | Lovable Deep scan | Human review |
|---|---|---|---|
| Missing RLS, known database misconfigurations | Yes | Yes | Yes |
| Dependencies with known vulnerabilities | Yes | Yes | Yes |
| Logic errors in policies (user A can read user B's orders through a join or a view) | Limited | Partly | Yes |
| Whether the data in a "public" table should be public at all | No | No | Yes, with you |
| Business rules (who may refund, who may see which customer) | No | Partly | Yes |
| What happens after launch, when the AI changes the schema again | Only on the next publish | Only when you run it | Only if repeated |
Crissy Field's conclusion is blunt: automated checks are no substitute for a professional security assessment, and access permissions should be reviewed again after significant changes. That matches what the scans can see. A tool can tell you RLS is on. It cannot tell you that your "bookings" table should not show other customers' phone numbers.
If personal data was exposed
- Close it first. Enable RLS, replace
truepolicies, revoke unneeded grants, make buckets private, rotate any leaked secret key. - Check the logs. Supabase API logs show requests to the tables in question. Note what was reachable, since when, and whether anything unusual read it.
- Know your notification duties. Under the GDPR, if the app has users in the EU, you have 72 hours from becoming aware of a personal data breach to notify your data protection authority (Article 33), unless the breach is unlikely to put people at risk. If the risk is high, as with ID documents or payment details, you must also tell the affected people (Article 34). In the US, every state has its own breach notification law. The obligation is yours as the app's operator, not Lovable's.
- Write it down. Keep a short record of what happened and what you changed. The GDPR requires it even when you do not notify.
Keep building on Lovable, harden the app, or rebuild?
| Situation | Reasonable next step |
|---|---|
| Prototype, demo data, no real users | Keep building. Run the Deep scan before each publish and keep test data fake |
| Real users, simple data, the check above came back clean | Keep building, turn on auto-fix for security findings, and repeat the check after every schema change |
| Personal, payment or health data, or business customers asking security questions | Get a human review of policies, functions and storage before you scale, and add tests for access rules |
| The product works, but every change breaks something and nobody understands the schema | Export the code to GitHub and have a developer take over the backend, keeping the parts that work |
Lovable syncs projects to GitHub, so moving to a developer does not mean starting from zero. The interface and flows you validated with users usually stay. What gets rebuilt is the part that decides who can see what.
What a security review of a Lovable app costs
Published prices checked on October 25, 2026 (more detail in our comparison of AI code audit services):
| Option | Price |
|---|---|
| Lovable Quick and Deep scans | Free |
| Automated repository audit (GitTruth) | $49 one-time |
| Automated scan with manual review (Triple Minds) | $299 for a scan; fixing critical and high findings $3,000 to $10,000 over 2 to 4 weeks |
| Senior engineers on call (VibeAudits) | Mentor plan $29 a month; partner engagements from $1,000 |
A review is cheap next to a breach that forces you to email every customer. The fix is where the cost sits, and it depends on how far the data model is from what the product actually needs.
FAQ
Is Lovable safe to use?
The platform has standard security controls and free security scans, but the apps it builds are only as safe as their database rules. In 2026 Crissy Field found tables with email addresses readable without login on 7,403 Lovable sites, including passport numbers and payment records in the worst cases, caused by missing or too-open Row Level Security in Supabase. Check your own app before it handles real customer data.
Was Lovable hacked?
Not in the Crissy Field case. Nobody broke into Lovable; the apps' databases answered anyone who asked. Lovable's own platform had a separate incident between February 3 and April 20, 2026, when public projects' chat history and source code were visible to other signed-in users. Lovable fixed it within two hours of the public report.
How do I check if my Lovable app is secure?
Run the Deep scan in Lovable's Security view, open the Supabase Security Advisor, and run the SQL checks above for tables without RLS, policies with true, grants to the anonymous role and public storage buckets. Then open the app logged out and see what the network responses contain.
Does Lovable fix security issues automatically?
Partly. Lovable can fix scanner findings from the Security view or the project chat, and an auto-fix setting resolves many of them with your next message. Since November 12, 2026, projects on the built-in backend get a review dialog before publishing with critical findings, but you can still publish anyway.
Is the Supabase anon key a secret?
No. The anon or publishable key is meant to be public and sits in your front end. Security depends on Row Level Security and grants. The service role or secret key is the one that must never reach the browser.
Do I need a developer to secure a Lovable app?
Not for a prototype with fake data. For an app that stores personal, payment or health data, a human review of access rules is worth it, because scanners cannot judge which data should be visible to whom.
Need someone to take a Lovable app to production?
I'm a freelance product builder in Kraków. I build MVPs and AI products with AI coding agents myself, on Next.js, Expo and Supabase, so I know where generated code tends to cut corners. I start with a workshop to agree on scope, then work in two-week sprints and get a working version in front of you as early as possible. Projects start at $5,000, with no upper limit, because the price depends on scope. I bill hourly on a B2B invoice. See AI MVP development, or send me the app you want to harden or rebuild and I'll reply within 24 hours.
Sources
Read November 16, 2026, unless noted.
- Crissy Field, Lovable: many apps built on the platform expose sensitive data (English report, November 2026; Handelsblatt article November 2, 2026)
- PrivacyAffairs, Lovable apps exposed passports and private chats. The fixes so far don't close existing leaks (November 14, 2026)
- Lovable, Our response to the April 2026 incident (April 22, 2026)
- Ascertify, Is Lovable secure? We scanned 70 public Lovable apps (September 16, 2026)
- CVE Program, CVE-2025-48757 (published May 30, 2025)
- Supabase, Breaking change: tables not exposed to Data and GraphQL API automatically
- Supabase, Row Level Security
- Lovable, Changelog (November 12, 2026 entries)
- Lovable, Project security view and Security overview
- UpGuard, Everything everywhere: systemic data exposure in Supabase apps (September 2026)
- Regulation (EU) 2016/679 (GDPR), Articles 33 and 34
Want to build an AI agent, an MVP, or an app?
I design and build AI products from the first version to production: MVPs, React Native mobile apps, web apps, and AI agents. Tell me what you want to build and I will tell you where to start.
