> ## Content Index
> Fetch the complete content index at: https://claudefox.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# Study: thousands of Lovable apps left user data readable through Supabase
- URL: https://claudefox.com/lovable-apps-supabase-data-exposure-study/
- Published: 2026-11-15T07:53:26.000Z
- Updated: 2026-11-15T07:54:37.000Z
- Description: A Crissy Field study of 159,041 Lovable projects found 7,403 sites where Supabase tables holding email addresses could be read without logging in, including passport details and 200,000 chat messages. Here is how to check your own app.
- Author: hupicake
- Tags: News

A security study of apps built on Lovable, the AI app builder, found that many of them let signed-out visitors read data that should be private. Hamburg-based security firm Crissy Field examined 159,041 Lovable projects found in the Common Crawl web archive between December 2025 and September 2026\. It worked with the German business paper Handelsblatt, where reporter Lina Knees first covered the findings on November 2, 2026\. Crissy Field has since published an English report with a newer analysis and updated figures.

## What the researchers found

The study looked only at apps that use Supabase as their database. Of the 159,041 projects, 34,545 did. Of those, 24,664 sent Supabase records as soon as the page loaded, with no login. That alone can be fine, since the data may be meant to be public. But with further read-only requests using the same key the page already ships, the researchers reached tables containing email addresses in 7,403 of those 24,664 sites (30%, the report's figure), 10,560 tables in total.

The examples in the report include:

- A German lifestyle forum with more than 80,000 profiles (names, emails, birth dates, gender) and more than 200,000 chat messages.
- Event organisers and restaurants exposing tens of thousands of ticket and food-order records, including phone numbers, postal addresses, payment information and ticket codes.
- A service provider exposing more than 1,000 identity-document records, including passport numbers, expiry dates and nationalities.
- A property manager's AI-generated summaries of internal emails about tenants and owners.
- Contracts, invoices, photo albums, internal WhatsApp messages and, in one case, 280,000 emails sent to a provider's customers.

The authors are careful about the limits. Records with email addresses can be public contact details or test data, and records without emails were missed; the report says these effects partly offset each other to an unknown extent, so the 30% figure is not a confirmed leak rate. The Common Crawl sample is not representative of every Lovable app, and the team did not examine Lovable's own built-in database, introduced in late 2025\. It downloaded only parts of each dataset, so the counts in the examples reflect what it retrieved and the affected datasets may hold more. It could not tell whether any of the data had been misused, and it is not publishing how to reach the records. Handelsblatt contacted Lovable; the English report does not quote a response.

Our arithmetic on the report's figures, with the same caveats: 7,403 sites is about 4.7% of all projects scanned and about 21% of the Supabase-backed ones. These are sites with readable tables holding email addresses, not confirmed leaks. Roughly 71% of Supabase-backed projects returned some database records on first load, which can be intended.

## Why this keeps happening

A Supabase app built this way talks to the database straight from the browser, using a key that is public by design. Supabase's docs say the publishable key can be exposed because it only reaches what Row Level Security (RLS) allows. So RLS and table grants together are the lock. Supabase warns that a table in an exposed schema without RLS is readable and writable by any role with a grant on it, that on existing projects a new table in the public schema starts with every privilege granted to the anon and authenticated roles (not every project grants these automatically), and that adding policies does not take those grants back. A policy written as using (true) for anon gives every signed-out visitor read access to every row the anon role's grants allow. Views also bypass RLS by default, because Postgres creates them as security definer.

The report makes two more points. Access-control mistakes can happen in any app, hand-written or AI-built. But because Lovable apps follow recurring patterns, an approach that works against one app may work against others with little extra effort, and builders without a technical background have a harder time spotting the flaw. It recommends reviewing access permissions, interfaces and the separation between user accounts before an app handles real data, and again after significant changes.

## What Lovable's tools already check

Lovable's security docs describe a Quick scan that runs automatically each time you publish and flags tables without row-level security, access rules that let everyone through, and leaked-password protection being off. A Deep scan reviews the app's code for access-control and data-exposure problems, but it does not run automatically. Workspace admins can turn on a setting that blocks publishing while critical findings are unresolved; Lovable says new Enterprise workspaces it creates start with that on. Lovable's docs also say the scans do not replace a thorough security review and that you are responsible for your app's security, which matches the report's point that Lovable's terms put responsibility on customers. The report does not say whether the affected apps had run these scans.

## How to check your own app

- In Lovable, open the project's Security view and run a Deep scan, not just the Quick scan that runs on publish.
- In Supabase, open the Security Advisor and review every finding before dismissing it.
- Check that RLS is enabled on every table in an exposed schema, and look at what anon and authenticated are granted. Fix it as one migration that sets grants and policies together, and run supabase test db on a local or branch database before production: once RLS is on, the publishable key reaches nothing until policies exist, so a half-done change can break a live app.
- Search your policies for using (true) on anon and keep it only on data that is meant to be public. Check views and security definer functions in exposed schemas too.
- Confirm that only the publishable (or legacy anon) key is in your frontend. A secret or service\_role key bypasses RLS entirely; if one has shipped, rotate it, not just remove it.
- As a first look, sign out and check what the site's network requests return. A clean result does not prove the tables are locked, since the researchers found more data with extra requests.

**Try it with your AI.** Give this to your coding assistant to audit a Supabase-backed app's access rules without changing anything.

```
Help me audit the Row Level Security setup of my Supabase project for [app name]. This
is a read-only review: do not execute any statement yourself, and do not ask me for the
secret or service_role key.

First, check: which schemas my app exposes through the Data API, and whether my frontend
code contains only the publishable (sb_publishable_...) or legacy anon key. If you find
a secret (sb_secret_...) or service_role key in client code, stop and tell me, do not
print it, and remind me to rotate it.

Then, for every table, view and security definer function in the exposed schemas:
1. Tell me whether RLS is enabled (for tables).
2. List the grants held by anon and authenticated.
3. List the policies, and flag any that apply to anon with using (true).
4. Flag views and security definer functions, which can bypass RLS.
5. Mark which tables hold personal data such as emails, names, addresses, phone numbers,
   payment or ID details.

Give me a table of findings. For each problem, draft the fix as a single migration file
that sets grants and policies together, using Supabase's documented statements, for
example alter table [table] enable row level security; and revoke all on table [table]
from anon, authenticated; followed by grants and policies for only what the app needs.
Tell me to test it with supabase test db on a local or branch database before
production. Output the migration for me to review; do not run it.
```

## FAQ

Is Lovable itself hacked? The report does not describe a breach of Lovable. It describes apps built on the platform whose database access rules let signed-out visitors read data.

Is the Supabase key in my page a leak? Not by itself. Supabase says the publishable or anon key is safe to expose; the protection comes from RLS policies and grants. The secret or service\_role key is the one that must stay on the server.

Does Lovable's security scan catch this? Its Quick scan checks for tables without RLS and policies that let everyone through on every publish. The report does not say whether the affected apps used it, and Lovable itself says the scans are not a full security review.

Was any of the exposed data misused? The report says it could not establish whether any of it had been misused.

Source: [Crissy Field: Lovable: Many Apps Built on the Platform Expose Sensitive Data](https://www.crissyfield.de/research/lovable-en/?ref=claudefox.com), [Handelsblatt (German): Hat die beliebte KI-Coding-Plattform ein Sicherheitsproblem?](https://www.handelsblatt.com/technik/ki/lovable-experten-finden-datenluecke-bei-beliebter-ki-coding-plattform/100264923.html?ref=claudefox.com), [Lovable docs: Security overview](https://docs.lovable.dev/features/security?ref=claudefox.com), [Supabase docs: Row Level Security](https://supabase.com/docs/guides/database/postgres/row-level-security?ref=claudefox.com), [Supabase docs: API keys](https://supabase.com/docs/guides/api/api-keys?ref=claudefox.com)

This story first appeared in the [claudefox daily briefing for November 15, 2026](https://claudefox.com/daily-2026-11-15/).