Lovable app data exposure: How Passports and Chats Were Exposed

Lovable app data exposure: How Passports and Chats Were Exposed Lovable app data exposure: How Passports and Chats Were Exposed

A large-scale investigation of applications created with Lovable uncovered passport details, private conversations, customer records and other sensitive information that could be retrieved without logging in. The Lovable app data exposure illustrates a crucial distinction in modern web security: an application can look complete and function correctly while its underlying database remains dangerously open.

Security researcher Crissy Field analyzed 159,041 Lovable projects found in Common Crawl datasets spanning December 2025 through September 2026. Of those projects, 34,545 used Supabase. According to the research, 24,664 websites returned some Supabase database records without authentication, while 7,403 had accessible tables containing email addresses. The most serious findings included more than 1,000 identity-document records and over 200,000 private messages.

Those numbers are alarming, but they require careful interpretation. They do not prove that 30% of Lovable applications suffered confirmed breaches, nor do they show that attackers misused the exposed information. What they reveal is a recurring failure to enforce database access controls in AI-generated applications.

What the Lovable security research found

Lovable is an AI app builder that can generate front-end interfaces, application logic and database integrations from natural-language instructions. Many projects connect to Supabase, a development platform built around PostgreSQL that provides authentication, storage and browser-accessible APIs.

For the investigation, Field used historical Common Crawl data to identify Lovable projects at a scale that would be difficult to achieve through manual discovery. The dataset contained 159,041 projects observed between December 2025 and September 2026. Researchers identified 34,545 projects using a Lovable Supabase integration and tested whether their databases returned records to an unauthenticated requester.

  • 24,664 websites returned at least some database records without requiring a login.
  • 7,403 websites exposed accessible tables containing email addresses.
  • More than 1,000 records contained identity-document information, including passport numbers, expiration dates and nationalities.
  • More than 200,000 private chat messages were accessible.
  • More than 80,000 user profiles were exposed across the examined projects.

The investigation also identified contracts, invoices, customer email addresses, internal WhatsApp communications and other records that appeared unsuitable for unrestricted public access. The detailed methodology and findings are available in Crissy Field’s published research.

The most serious exposed records

Not every record returned through a public interface is confidential. A product catalog, public directory or community post may be intentionally available without authentication. Passport records and private messages are fundamentally different.

The exposed passport-related entries reportedly included document numbers, expiration dates and nationalities. In combination with names or other identifying details, this information can create identity theft, impersonation and social-engineering risks. Contracts and invoices may reveal financial relationships, addresses, pricing or signatures. Internal WhatsApp messages can expose business discussions, employee information and operational decisions.

The volume of private messages—more than 200,000—also highlights why database authorization must operate at the level of individual records. Requiring a user to sign into an interface is not enough if that person, or an unauthenticated visitor, can call the database API directly and retrieve conversations belonging to others.

Field could not establish whether anyone had previously discovered, downloaded or misused the information. Public accessibility confirms exposure, but it does not by itself prove exploitation or a completed data breach.

Why this is not a confirmed 30% breach rate

The figures have sometimes been interpreted too broadly. Of the 24,664 websites returning records, 7,403 had accessible tables containing email addresses—roughly 30%. That ratio should not be described as a confirmed breach rate.

First, some publicly returned records may have been intentionally exposed. A website may legitimately make selected database content available to everyone. Second, the presence of an email field is an imperfect proxy for sensitive personal information. An address could be a public business contact, test value or data meant for publication. Conversely, a table without email addresses could still contain highly sensitive information.

Third, Common Crawl is not a representative inventory of every application built with Lovable. It contains web pages discovered through its own crawling process, potentially overrepresenting public, indexed and long-lived projects while omitting private or undiscovered applications. The findings demonstrate a substantial security pattern within the examined sample, not the prevalence of breaches across Lovable’s entire customer base.

Finally, a security exposure and a breach are not interchangeable. Exposure means data could be accessed under conditions that appear unauthorized or overly permissive. A confirmed breach generally requires evidence that an unauthorized party actually obtained or used it. The research established the former in serious examples but could not establish the latter.

Public Supabase API keys were not the vulnerability

Seeing a Supabase URL and public API key in browser code can look suspicious, but their presence alone is not evidence of a Lovable data leak. Supabase’s public or anonymous key is designed for use in client-side applications. A browser needs it to identify the project and submit API requests.

The security boundary is supposed to exist in the database. PostgreSQL Row Level Security, commonly called RLS, determines which rows a request may read, create, change or delete. Policies can consider whether a requester is authenticated, the requester’s user ID, the ownership of a record and other application-specific conditions.

For example, a secure chat policy might allow authenticated users to read a message only when they belong to that conversation. An invoice policy might permit customers to view invoices associated with their own account while allowing employees with an authorized role to access broader records. Without those controls, possession of the ordinary public key may be enough to query any table exposed through the API.

The likely root causes in the affected applications included missing RLS, incomplete database policies, authorization checks applied only in the user interface and rules that granted anonymous or authenticated users more access than intended. Supabase provides detailed guidance for configuring Postgres Row Level Security.

A service-role key is different. It is privileged, can bypass RLS in normal configurations and must never be embedded in browser code. Client applications should use public credentials backed by restrictive policies; privileged operations should run in trusted server-side environments.

How AI-generated applications amplify access-control mistakes

AI app builders can make software development faster, but speed can compress or bypass the security review normally applied to database design. A generated application may produce polished pages, working authentication and successful data requests without proving that each requester is authorized to access each record.

This creates a deceptive result: the login screen works, yet the API may remain open. Front-end code might hide an administrative page or filter records to the current user, but those interface restrictions provide no meaningful defense when someone can send requests directly to the database endpoint.

AI-generated applications can also reproduce an insecure pattern across many tables and projects. If a template, generated migration or suggested policy prioritizes getting the application working, developers may disable RLS temporarily, add broad permissions or postpone authorization work. A configuration mistake that once affected one hand-built application can therefore appear repeatedly at machine-assisted development speed.

This does not mean every Lovable application or Supabase project is insecure. It means users cannot delegate responsibility for database access control entirely to an AI app builder. The developer or organization deploying the application remains responsible for validating its security assumptions and protecting the data it collects.

Security checklist for Lovable and Supabase applications

Teams using AI-assisted tools should treat generated database configurations as untrusted until they have been independently verified. A practical database security audit should include the following steps.

  1. Enable and test RLS. Confirm that Row Level Security is enabled on every API-accessible table containing user, tenant, financial, identity or communication data. Creating policies without enabling RLS is not sufficient.
  2. Deny access by default. Begin with no access and add narrowly defined permissions for necessary actions. Avoid policies that broadly allow anonymous users or every authenticated account to read all rows.
  3. Test as an unauthenticated visitor. Send direct API requests without a session. Verify that private tables return no records and reject inserts, updates and deletions.
  4. Test horizontal authorization. Create two ordinary accounts and attempt to access each other’s profiles, messages, files and transactions. Changing a record ID or user ID must not bypass ownership checks.
  5. Use server-side authorization for privileged operations. Administrative exports, payment changes and sensitive account actions should run through trusted server code that verifies identity, role and intended scope.
  6. Keep service-role keys out of browser code. Store privileged credentials in protected server-side secrets. Rotate them immediately if they appear in a client bundle, repository or public log.
  7. Separate tenant data. Multi-tenant applications should associate every protected record with a tenant and enforce tenant membership in database policies, not merely in front-end filters.
  8. Review every generated change. Database migrations and AI-suggested policies should receive the same code review as manually written security logic.
  9. Commission an independent review. Before production deployment, have someone who did not build the application test its APIs, RLS policies, authentication flows and privileged functions.

These checks should be repeated after schema changes. A secure policy on one table does not automatically protect a newly created table, view, storage bucket or server function.

The larger web application security lesson

The Lovable app data exposure is not simply a story about visible API keys or one development platform. It demonstrates how easily authentication can be mistaken for authorization. Authentication answers who a user is; authorization decides what that user may do with each record.

AI tools can generate code rapidly, but they cannot assume the organization’s privacy requirements, tenant boundaries or acceptable access model. As of November 2026, there is no evidence from Field’s investigation establishing that the exposed information was misused. There is, however, clear evidence that sensitive applications require tested, database-enforced controls before they go live.

Frequently asked questions

Was the Supabase public API key itself leaked?

A Supabase anonymous key is intentionally used in browser applications, so seeing it in client code is not inherently a vulnerability. The problem arises when database policies allow requests made with that public key to retrieve records that should be restricted. Service-role keys, by contrast, must remain secret and server-side.

Did 30% of Lovable applications suffer a data breach?

No. The percentage is derived from 7,403 sites with accessible email-containing tables among 24,664 sites that returned records. Some records may have been intentionally public, email fields do not always prove sensitive data exposure, and Common Crawl is not representative of all Lovable projects. The research also did not prove unauthorized exploitation.

What is Supabase Row Level Security?

Supabase RLS uses PostgreSQL policies to control access to individual database rows. Policies can restrict reads and changes based on authentication status, user identity, ownership, role or tenant membership. It is a core defense for applications that query Supabase directly from a browser.

How can developers check whether their application is exposed?

Test the database API without logging in, then repeat tests using multiple ordinary accounts. Attempt to read and alter records belonging to other users or tenants. Review every API-accessible table, verify RLS is enabled and obtain an independent security assessment before handling sensitive production data.

Leave a Reply

Your email address will not be published. Required fields are marked *