LovableSupabaseVibe CodingApp SecurityRow Level Security

Lovable Apps Data Exposure: How to Check and Lock Down Your Supabase

person
LaunchBoosts Research Desk·AI-assisted research
8 min read

Researched and drafted with AI assistance from the 6 public sources listed at the end of this article, then published after automated editorial checks. Spotted an error? Tell us at support@launchboosts.com.

Lovable Apps Data Exposure: How to Check and Lock Down Your Supabase — LaunchBoosts

A new study found that thousands of apps built with Lovable send database records to anyone who loads the page, no login needed. In some apps those records include passport numbers, payment details and private chats. Lovable's own servers were not breached. The data leaked from each app's Supabase database because the access rules were missing or too broad, so the fix is in your hands. Below is what the research found, why it keeps happening, and a step-by-step audit you can run on your own app today.

What the Lovable research actually found

The research was done by the German security firm Crissy Field together with the business daily Handelsblatt, which first reported it on November 2, 2026. Crissy Field's English report gives updated figures. The researchers found Lovable projects through Common Crawl data collected between December 2025 and September 2026.

Metric Figure
Lovable projects analyzed 159,041
Projects using Supabase 34,545
Supabase sites sending database records on page load, without login 24,664
Sites where further read-only requests returned records with email addresses 7,403 (about 30%), across 10,560 tables

Some examples of exposed data, according to the report:

  • A German lifestyle forum leaked more than 80,000 profiles (full names, emails, dates of birth, gender) and more than 200,000 chat messages.
  • A service provider leaked more than 1,000 identity-document records, including passport numbers, expiry dates and nationalities.
  • Event organizers and restaurants leaked tens of thousands of ticket and order records, with phone numbers, postal addresses, payment information and ticket codes.
  • A property management company leaked AI-generated summaries of internal emails about tenants and owners.
  • Elsewhere: contracts, invoices, photo albums, WhatsApp exports, waitlists, support tickets, and 280,000 emails one provider had sent to its customers.

The caveats matter

The researchers are careful about their own numbers, and you should be too:

  • The 30% figure is not a confirmed leak rate. Some of those emails are public contact or test addresses. The method also misses personal data that has no email field.
  • The sample doesn't represent every Lovable app. It only covers apps visible in Common Crawl that use Supabase.
  • Lovable's own database features were not studied. Techzine notes that the database functions Lovable has offered since late 2025 were outside the study's scope.
  • The real exposure may be larger. The researchers only downloaded parts of each dataset.
  • Misuse is unknown. The researchers could not tell whether anyone had already exploited the data.

Why vibe-coded Supabase apps leak

The report doesn't name one technical bug. It blames "access control mistakes in database integrations" that "follow recurring patterns." That pattern is what makes this dangerous: once an attacker learns one Lovable-plus-Supabase setup, the same approach often works on the next app, as Techzine puts it.

To understand the pattern, it helps to know how Supabase works:

  1. The browser talks to the database directly. A Lovable frontend calls Supabase's auto-generated REST API using a public key, called the anon or publishable key. That key is in your JavaScript bundle and anyone can copy it. This is intended.
  2. Row Level Security (RLS) is the only gate. Postgres RLS policies decide which rows that public key can read or write. Supabase's docs say to "Enable RLS on every table in an exposed schema".
  3. New tables are not locked by default. The same docs say that on existing projects, new tables in the public schema start with every privilege granted to the anon and authenticated roles. Turning RLS on for every new table automatically takes an event trigger you set up yourself.
  4. Policies can exist and still be useless. A policy like using (true) lets everyone read everything. A policy that only checks "is the user logged in" lets any signed-up account read every other user's rows.

When an AI builder creates tables quickly from prompts, any of these gaps can reach production. Your app still works, so nothing tells you anything is wrong.

This is not the first time

In 2025, CVE-2025-48757 (published May 30, 2025, CVSS 3.1 score 9.3) described "an insufficient database Row-Level Security policy in Lovable" that let unauthenticated attackers read or write arbitrary tables in generated sites. Lovable disputed the CVE, saying each customer is responsible for protecting their app's data. The new report points out the same tension: Lovable's terms put responsibility on customers, while its marketing suggests you need little technical knowledge.

Whatever you think of that split, it leaves you holding the risk. If your app leaks user data, you are the one answering to your users and, in the EU, to regulators.

How to check your own app (30-minute audit)

You don't need a security firm to find the obvious problems. Run these steps on every Supabase-backed app you've shipped, whether you built it with Lovable, Bolt, Cursor or by hand.

1. Run Supabase's Security Advisor

Open https://supabase.com/dashboard/project/YOUR_PROJECT_REF/advisors/security (replace YOUR_PROJECT_REF with your project's reference ID), or run supabase db advisors with the CLI. Supabase's advisor docs list the lints that matter most here:

Lint Level What it means
0013_rls_disabled_in_public ERROR A public table can be accessed without RLS
0023_sensitive_columns_exposed ERROR Sensitive columns are readable without RLS
0010_security_definer_view ERROR A view bypasses RLS
0015_rls_references_user_metadata ERROR A policy trusts metadata users can edit themselves
0024_permissive_rls_policy WARN A policy's condition is always true
0007_policy_exists_rls_disabled INFO You wrote policies but RLS is off, so they don't apply
0025_public_bucket_allows_listing WARN Anyone can list the files in a storage bucket
0028_anon_security_definer_function_executable WARN Anonymous users can call a privileged function

Fix everything at ERROR level before you do anything else. Some findings may be intentional, such as a public blog posts table, but you should be able to say why for each one.

2. Test like an outsider

Linters only check configuration. To see what an attacker sees, open your live site in a private window, look in the network tab for requests to *.supabase.co, and copy the project URL and apikey header. Then, without logging in, ask for each table (replace the uppercase placeholders with your own values):

curl "https://YOUR_PROJECT_REF.supabase.co/rest/v1/YOUR_TABLE?select=*&limit=5" \
  -H "apikey: YOUR_PUBLIC_KEY"

If rows come back from a table holding users, orders, messages or documents, it's exposed. Repeat while logged in as a normal test user and try to read another user's rows. This second check catches the "logged in means allowed" mistake, which a quick look misses.

3. List tables without RLS and policies that allow everything

In the SQL editor:

-- Tables in public with RLS off
select tablename from pg_tables
where schemaname = 'public' and rowsecurity = false;

-- Policies whose condition is literally "true"
select tablename, policyname, cmd, roles
from pg_policies
where schemaname = 'public' and (qual = 'true' or with_check = 'true');

4. Check storage and keys

Look at every storage bucket. Anything holding IDs, contracts or invoices should be private and served through signed URLs. Also search your frontend bundle for the service_role or secret key. Supabase says the service role "bypasses RLS, so keep it server-side." If it ever shipped to the browser, rotate it right away.

How to fix what you find

Enable RLS, then add the narrowest policy that keeps your app working. The standard pattern from Supabase's docs looks like this:

alter table public.profiles enable row level security;

create policy "Users read own profile"
on public.profiles for select
to authenticated
using ( (select auth.uid()) = user_id );

Practical notes:

  • Write a policy for each action. Select, insert, update and delete each need their own decision. For update and insert, a with check clause stops users from writing rows that belong to someone else.
  • Revoke leftover grants. The docs note that adding policies doesn't remove existing grants. On older projects, revoke anon access to tables that unauthenticated users should never touch.
  • Don't base access on user_metadata. Users can edit it themselves. Keep roles in a table they can't write to.
  • Index the columns your policies filter on, such as user_id, and wrap auth.uid() in select so Postgres evaluates it once per query instead of once per row.
  • Move sensitive work server-side. Passport scans, payment data and admin views belong behind an Edge Function or backend that checks authorization, not behind a client query and a policy you hope is right.

After fixing, run step 2 again. A policy only counts as working if you've seen it block a request.

If data was already exposed

Closing the hole doesn't undo past exposure. Check your Supabase API logs for unusual bulk reads from unknown IPs. Write down what was exposed and for how long. If you serve EU users, get advice on GDPR breach-notification duties, which can apply even when you can't prove anyone downloaded the data.

What Lovable's built-in tools do and don't cover

According to Lovable's security docs, you get two automated scans:

  • Quick scan. It runs automatically on every publish and includes a database review, a dependency audit and an MCP server check.
  • Deep scan. It reviews all your code for access control problems, unauthenticated endpoints, leaked secrets, payment and authentication issues, and exposed personal data. It does not run automatically: you start it from the Security view or by asking in chat. Auto-fix doesn't apply to its findings.

Workspace owners on Business and Enterprise plans also get a Security center that shows findings across all projects. Optional Wiz and Aikido integrations add static analysis and AI-run penetration tests.

The docs are clear about the limits. The tools "cannot guarantee complete security." For apps handling sensitive data, they recommend an extra professional review and checking RLS policies again after any authentication or database change. In practice:

  1. Run a Deep scan before launch and after every schema change, not just the automatic Quick scan.
  2. Treat "the scan passed" as the minimum, not proof you're safe. A scan can confirm a policy exists without confirming it's correct.
  3. Repeat the outsider test from step 2 above on a regular schedule.

What to do now and what to watch

This week: list every live app you've built on Supabase, including old prototypes and waitlist pages, and run the four audit steps on each. Abandoned demos with real signups are a common source of leaks like the ones in this report.

Before your next launch: add "outsider test passes for every table" to your release checklist next to performance and SEO checks. If you're about to list a vibe-coded product, say on the LaunchBoosts launch leaderboard or through the free submission form, launch traffic will bring exactly the curious visitors who open the network tab. Lock things down first. If you're comparing AI builders and coding assistants, the AI coding assistants category is a good starting point. Judge each one on how it handles database authorization by default, not just on how fast it builds.

What to watch: whether Lovable answers the report publicly or changes its defaults, for example by turning RLS on for every generated table or running the Deep scan automatically. Also watch whether researchers repeat this kind of Common Crawl survey for other AI app builders. The pattern isn't unique to one platform: whenever a browser talks straight to a database, RLS is the only lock.

Frequently asked questions

Was Lovable itself hacked?

No. Nobody broke into Lovable's own systems. The researchers found data that individual Lovable-built apps returned through their own Supabase databases, because those databases had weak or missing access rules. The data belongs to each app's users, and fixing it is up to each app's owner.

Is it a problem that my Supabase anon or publishable key is visible in the browser?

The key itself is not the problem. It is meant to be public and is shipped to the browser by design. The danger comes from tables that key can read or write when Row Level Security is off or a policy is too broad. Once RLS is on, Supabase docs say the publishable key gets no data until you create policies.

Does Lovable's built-in security scan catch this?

It catches some of it. The Quick scan runs on every publish and includes a database review. The Deep scan reviews access control and exposed personal data, but you have to start it yourself. Lovable's docs say the tools cannot guarantee complete security and recommend a professional review for apps that handle sensitive data.

Were apps using Lovable's built-in database included in the study?

No. The study only covered Lovable projects backed by Supabase. Lovable's own database features, available since late 2025, were not part of it, so the findings say nothing either way about those apps.

How do I quickly test whether my app leaks data?

Copy your project's public Supabase URL and anon/publishable key from your site's frontend. Then, without logging in, send a REST request to each table, for example a GET to /rest/v1/your_table?select=*&limit=5 with the key in the apikey header. If rows that should be private come back, that table needs RLS and a proper policy.

Sources

  1. Crissy Field research: Lovable applications exposing sensitive data— crissyfield.de
  2. Techzine Global: Thousands of Lovable apps are leaking personal data— techzine.eu
  3. Supabase docs: Row Level Security— supabase.com
  4. Supabase docs: Database Advisors (security lints)— supabase.com
  5. Lovable docs: Security features— docs.lovable.dev
  6. Tenable: CVE-2025-48757 (Lovable insufficient RLS policy)— tenable.com
person

LaunchBoosts Research Desk

AI-assisted research

Explainers on software and AI industry trends, drafted with AI assistance from the public sources cited in each article and published after automated editorial checks for length, independent sourcing and originality.