Diesen Artikel auf Deutsch lesen →
security · · · Streatix

Lovable Data Leak: 76 Days of Exposed Code and Chats

A Lovable regression exposed public projects' code and chat history for 76 days. How BOLA reports got closed as intended, and what to rotate now.

On April 20, 2026, a researcher posting as @weezerOSINT said they had made a free Lovable account, sent five API calls, and read another user’s source code, database credentials and AI chat history. That is the Lovable data leak, and Lovable’s own account bounds it: between February 3 and April 20, public project chat history and source code “could potentially be accessed by any Lovable user provided they had a project link.” Private projects, it says, were never affected. The researcher said they had filed the finding through HackerOne 48 days earlier and got a “duplicate” label. After the public post, Lovable shipped a fix within two hours. The number worth reading is the 76 days before that, and the reason the clock ran so long: inside Lovable, the bug had a paper trail that said it was a feature.

We build deliberately broken reference apps to learn what these tools ship, and we wrote up a Lovable app that leaked every user’s data through disabled RLS. That was a flaw in the code Lovable generates for you. This one is a flaw in Lovable itself, the platform that holds the code. Nothing was misconfigured by a founder. The provider had built the protection, walked back over it, and then could not see the reports telling it so.

The protection existed, then a refactor undid it

Lovable started out open by design: on the free tier, all projects were public by default, and you needed a paid plan to go private. It then hardened in steps. In March 2025, chat history and source code for public projects stopped being reachable through the API. In May 2025, Enterprise users lost the ability to create public projects. In November 2025, all new projects on every tier became private by default. The order is the problem. The new default covered new projects, so projects created earlier as public stayed public, protected only by the March change.

In February 2026, a backend change undid that. In Lovable’s own words: “A backend regression reintroduced access to chat histories on public projects,” undoing protections it had “deliberately put in place between March and November 2025.” Its statement on X named the cause: “while unifying permissions in our backend, we accidentally re-enabled access to chats on public projects.” This is the most ordinary kind of regression. A team consolidates permission systems, and the new path has a gap the old path covered. A negative test asserting that a stranger gets a 403 would have caught it. We haven’t seen Lovable’s test suite, but those are the tests nobody writes for a property they assume is structural, and the ones that exist tend to build fixtures with the current defaults, so they exercise new private projects and never the legacy public ones.

The Lovable data leak was BOLA: the API checked who you were, never what you owned

The flaw the researcher demonstrated is Broken Object Level Authorization, the number one entry on the OWASP API Security Top 10. As reported, the project-messages endpoint authenticated the caller, confirmed a valid logged-in user, and then served a project still flagged public, chat history and source included, without checking that the caller owned what came back. Authentication intact, object-level authorization gone. With the March 2025 protection gone, “public” went back to meaning “readable by a logged-in stranger.”

It rhymes with the cosmetic page guard we wrote up, where the dashboard redirects to a login screen while the API behind it answers anyone. In both, the protection a user can see is not the one the server enforces. There the gap was the app’s. Here it is the platform’s, on its own control plane. Reporting on the demonstration says the split fell on the November 2025 line, with older projects open and newer ones closed, which fits legacy public flags rather than a toggle a founder forgot to flip. The researcher’s “every project created before November 2025” is wider than what Lovable describes, because private projects from that period were not exposed.

What came back is what makes a vibe-coding leak different from an ordinary source leak. Lovable confirms chat history and source code. The researcher also claimed database credentials and customer data, and the mechanism makes that plausible: credentials hardcoded in the source come along with the source, and those credentials unlock the data behind them. For an app built by prompting, the chat history is the build log, and founders paste secrets into it: connection strings, third-party API keys, the contents of a .env they wanted the model to wire up, error dumps with live tokens in the stack trace. Any Supabase keys in there carry the blast radius we walked through in the RLS post. Leaking the conversation can out-leak the repository.

The reports arrived on day 19 and died in triage

Here the story stops being a normal regression. Researchers started reporting this through Lovable’s HackerOne program on February 22, nineteen days into the window. The researcher’s report, dated March 3, was reportedly marked a duplicate of an existing report titled “Broken Object Level Authorization on Lovable API leads to unauthorized access to user data and project source code.” The bug class, the surface and the impact, in the title.

None of it reached Lovable’s security team. Lovable’s explanation: “The decision to close the reports was based on internal static documentation and context we had provided to our HackerOne partners, which still described public project chat visibility as intended behavior.” That had been true once. Public chat was accessible by design until March 2025, and the documentation was never updated after the hardening that made it a vulnerability. So accurate reports pattern-matched against a stale doc and got filed as noise.

This is the failure worth naming, because most teams reading this have a live copy of it. Call it closed as intended: the authorization truth lived in a document, the document was wrong, and the people guarding the front door were reading it instead of the code. Bug bounty triage is usually outsourced, a vendor’s first-line analysts filtering noise against the runbook the customer handed them. The reports were not missed. They were received, read, checked against the recorded definition of correct, and rejected for disagreeing with it. By our reading, two copies of what “secure” meant had gone stale at once: the test suite that should have failed, and the triage doc that should have escalated.

There is a sibling failure in our Meta support-AI teardown. There, by our reading of the reports, a privileged action sat within reach of a conversation, and the check that should have stood behind it did not run. Here, the decision sat inside a document nobody brought up to date. In both, no deterministic check stood behind the gate to catch it when it stopped matching the truth.

The fix took two hours, because engineering was never the blocker

When the researcher published on April 20, Lovable shipped a fix within two hours. A spokesperson told The Register the company wasn’t aware of the issue until that Monday. A defect that takes two hours to close once someone with authority believes it was never blocked by engineering difficulty. The feedback path from “a stranger can read this” to “an engineer who can fix it” was the broken part, and patch speed at the end repairs none of the 76 days the signal spent getting routed to a closed ticket.

The fix: revert the regression, and then the broader remediation, make all historically public projects private except Lovable’s official templates. The second step is what retires the risk for the old projects, because it stops relying on a per-request check being perfect and removes the public state that made them reachable. Lovable also moved remixing to opt-in, committed to retraining its HackerOne triagers, and said it is reviewing which public projects were viewed by users other than their owners, and will contact those owners.

The first response blamed everything except the regression

The same-day messaging is a case study in how not to hold an incident. The Register captured the arc: Lovable first said it “did not suffer a data breach” and called the exposure “intentional behavior,” attributed the confusion to unclear documentation of what “public” meant, then pointed at HackerOne for closing the reports. Three stances in a day, and each put the cause somewhere other than the regression. The post-mortem on April 22 was straighter, conceding that “our first public response was dismissive and failed to acknowledge the real concern.” The honest version arrived fourth.

We read the “intended behavior” defense as the tell that the company’s own mental model had drifted to match the stale triage doc. If that’s right, nobody was lying when they first said it. They were reading the same outdated definition of correct that had closed every report.

What we can’t confirm, and won’t assert

A few things are not pinned down, and a teardown that papers over them repeats what Lovable’s triage did. The proof of concept reportedly pulled real user records from a nonprofit’s live app. We couldn’t confirm that independently, so treat it as reported. Lovable says reaching a project required its link, while the five-API-calls demonstration implies project identifiers were discoverable or could be walked. No source we trust resolves whether a stranger could enumerate projects or had to obtain links first, and that is the difference between a targeted leak and a bulk one. Lovable has published no count: not how many projects were read, not how many owners were notified, not how the review concluded. Until those land, the honest scope is “public projects were reachable by a logged-in Lovable user with a link, for 76 days,” with enumeration unresolved, not “every project was taken.”

If you shipped on a platform, you inherited its regressions

The lesson for a founder is not to leave Lovable. Putting your code on a managed platform moves a class of risk you can’t see and can’t patch. Your source, your keys and your prompt history sit inside someone else’s authorization model, and when that model regresses you find out on the provider’s schedule, through the provider’s triage, calibrated to the provider’s possibly stale idea of what’s intended. You can’t audit that boundary. You can only narrow what’s behind it.

Two moves are in your hands today. Rotate every credential that ever touched a Lovable project that was public, which on the free tier before November 2025 meant all of them by default, because a leaked key stays leaked until it’s revoked and deletion is not revocation. And stop pasting live secrets into the prompt, because the chat history is a durable store whose access rules you don’t control.

The provider had the right protection, retired it by accident, and was told 19 days in by people who had reproduced it. The last thing to fail was the document that defined what the code was supposed to do, and the people downstream who trusted the document over the bug report. Check what yours says, and check who’s allowed to disagree with it.

If you want this for your own app

Thirty-minute audit, free. We curl the same endpoints and read the same files. List in your inbox within forty-eight hours.

Book a free audit