In short
- 2,802 apps were read the way a browser reads them: the page and the JavaScript it loads. No backend was queried, no key was tried and no account was created.
- 78% of the apps run on Supabase. Of those, 80% name at least one table in code any visitor downloads. The median app names 11, one in ten names 43 or more, and 22 apps name over 100.
- Secrets in the bundle have become rare: 4 real ones in 2,802 apps. Three were keys for AI services called straight from the browser. The fourth was a default password in an admin script.
- Eleven other matches were examples, placeholders or library code. A tool that reported every string shaped like a key would have been wrong about three times out of four.
- A table name is not a flaw. It tells a stranger what to ask for, so the rules behind each table are the only protection, and reading code cannot show whether they hold.
On this page
- What we read, and what we did not
- Supabase is the default backend of AI-built apps
- Four Supabase apps in five tell visitors the names of their tables
- Secret keys in the bundle have become rare
- Eleven false alarms for four real findings
- One app in sixty serves its source maps
- What this read cannot tell you
- Run the same read on your own app
- What Keybrum does with these numbers
- Questions
- Sources
What we read, and what we did not
Most vibe coding security statistics come from tests that sent requests to other people's databases. This study does something narrower and safer. On 13 and 14 November 2026 we opened 3,065 app addresses the way any visitor's browser does, and 2,866 answered with a page we could read.
The addresses come from two public lists. The first is the Lovable partner directory, where 728 agencies in 93 countries show the apps they built: 2,391 of them answered. The second is Made with Lovable, a public showcase where makers submit their projects: 475 answered. Some sites appear in both lists, or twice in one, so we counted each site once: 2,802 distinct sites. Every number below counts each site once. These are apps that someone chose to show, so they are probably in better shape than the average project.
| We did | We did not |
|---|---|
| Load the page and the JavaScript files it references, at most 120 requests per app | Send any request to a database, an API or a function |
| Note the backend, the framework and the host the code reveals | Sign up, sign in or submit a form |
| Count the table and function names written in the code | Ask any table for a row |
| Look for strings in the format of secret keys, then re-read each match in its context | Try a key, or call the provider that issued it |
That limit matters for reading the numbers. We can say what an app shows. We cannot say what its database would answer, because we never asked.
Supabase is the default backend of AI-built apps
| What the code reveals | Apps | Share of the 2,802 |
|---|---|---|
| A Supabase project address and its public key | 2,191 | 78.2% |
| A Firebase configuration | 10 | 0.4% |
| Stripe loaded in the page | 261 | 9.3% |
| Vite with React | 2,617 | 93.4% |
| Lovable's own mark still in the page | 1,225 | 43.7% |
Finding the Supabase address and the public key in the code is expected. Supabase designs that key to be shipped to the browser, and the Supabase anon key guide explains why it is not a secret. The consequence is that every one of these 2,191 apps lets the visitor's browser talk to the database directly. What the visitor gets back is decided by the grants and the row level security policies on each table, and by nothing else.
Four Supabase apps in five tell visitors the names of their tables
A generated frontend reads data with calls like supabase.from('orders'). Those calls are in the JavaScript, so the names are too. We counted them.
| Among the 2,191 Supabase apps | Result |
|---|---|
| Name at least one table | 1,760 apps (80.3%) |
| Tables named by the median app that names any | 11 |
| Tables named by the top quarter | 24 or more |
| Tables named by the top tenth | 43 or more |
| Apps naming 50 tables or more | 134 |
| Apps naming 100 tables or more | 22 |
| Largest count in one app | 525 |
| Name at least one edge function | 1,222 apps (55.8%), 7 on the median app |
| Name at least one database function | 1,059 apps (48.3%), 4 on the median app |
An app that names 43 tables needs 43 sets of policies that are each right, for reading and for writing. The agent that wrote the app added a table whenever a feature needed one. Nothing forced it to add the policy at the same moment.
Secret keys in the bundle have become rare
We looked for strings in the format of several dozen kinds of secret: keys for AI providers, payment providers, email services, cloud accounts, database addresses with a password, private keys and passwords written in code. Fifteen apps had a match. We read each one in its context. Four were real.
| What was served to every visitor | Where it was |
|---|---|
| A key in the format of an OpenAI secret key | The value of a VITE_ variable, copied into the bundle at build time |
| A key in the format of an OpenRouter key | The Authorization header of a call made from the browser |
| A Google API key used to call the Gemini API | A constant next to the address of the Gemini endpoint |
| A default password for new records | An admin script that downloads without sign-in |
Three of the four are the same mistake: an AI feature that calls the provider straight from the browser, so the key has to travel with the page. The providers warn against it in plain words. Google's documentation for Gemini keys says: "Never expose keys client-side in production." OpenRouter recommends a credit limit on every key and says a key without one should stay out of client-side code.
Four in 2,802 is low, and we think that is good news with a cause. The builders now look for this. Lovable's documentation says it detects API keys pasted into the project chat and guides the builder to store them in Secrets instead of the code. A VITE_ or NEXT_PUBLIC_ prefix remains the common trap. The guide to API keys exposed in the frontend covers the fix, and what to do with a leaked key gives the order to act in.
Eleven false alarms for four real findings
The other eleven matches looked like secrets and were not. Reading them one by one took longer than finding them, and it is the part a quick scan skips.
- Placeholders in forms. A settings screen with a field for an API key often shows a sample value in the field. Five matches were that.
- Examples in documentation. Two apps display API examples or deployment commands that contain sample keys and a sample database address.
- Mock data. One app shows a list of fake API keys in a demo screen.
- Library code. Two matches were the text a cryptography library uses to recognise a private key.
- A signed download link. One match was the public part of a temporary link to a video file.
If your scanner tells you a secret is in your bundle, open the file and read the lines around it before you worry. If it is a real key, only the provider can say whether it still works, and that is a check for the owner to run. We never try a key that is not ours.
One app in sixty serves its source maps
46 apps (1.6%) serve source maps next to their JavaScript. A source map turns the compressed bundle back into the original files, with their names and comments. It hands a visitor the frontend's source code. That is rarely a disaster for a frontend, and it makes every other question on this page easier for a stranger to answer. Most hosts let you switch them off for production builds.
What this read cannot tell you
The number that matters most is missing from this page: how many of these tables answer a request from a stranger. Two studies did send read requests. The scan behind CVE-2025-48757 found tables open to strangers in 170 of 1,645 Lovable apps. In November 2026 a German firm examined 24,664 sites built with Lovable and retrieved records containing email addresses from 7,403 of them, while warning that the figure should not be read as a confirmed leak rate. The Lovable data leak guide reads both.
We did not repeat that. Asking someone else's database for rows, even to warn them, is access they did not agree to. So our figures describe the surface: what is named, what is shipped, what is exposed by the bundle. Whether the rules hold is a question each owner can answer on their own app, and it takes one request per table.
Run the same read on your own app
- 1
List what your bundle names
Open your live site, open the developer tools and search all loaded scripts (Ctrl+Shift+F in Chrome) for
.from(. Each result is a table a stranger knows about. - 2
Search for key prefixes
In the same search box, try
sk-,sk_live_,sb_secret_,sk-or-andAIza. A Google key next togenerativelanguage.googleapis.comis a Gemini key in the browser. - 3
Read the lines around each match
A placeholder or an example is harmless. A real key in a variable or a header is not: revoke it at the provider before you change the code.
- 4
Ask your database the question we did not
In the Supabase SQL editor, list the tables with row level security off. The Supabase RLS checker gives you the query. Then sign up twice and try to read the first account's records from the second.
What Keybrum does with these numbers
The free check at /check is the same passive read, on one app, with the result on your screen. It names the angles and stops there.
The attack is the part this study left out, and it only runs on an app whose owner has proved it is theirs. Keybrum asks each named table for rows with no account, then with a new account, then with a second account against the first one's records. A table that answers becomes a finding with the request and the response, personal data redacted, and the policy to add. A one-time report costs €49. Plans, from €29 a month excluding VAT, attack every deploy, which is when the next table appears.
Questions
Are table names in my JavaScript a vulnerability?
No. On Supabase the frontend talks to the database, so the names of the tables it uses are in the code by design. In our read, 80% of Supabase apps named at least one. The protection is the row level security policy on each table, which you check in the database and not in the bundle.
How many vibe-coded apps leak API keys?
In our read of 2,802 apps in November 2026, four served a real secret, or 0.14%. The sample is made of apps that agencies and makers chose to list, so the rate across all projects is probably higher. Counts differ between studies because they count different things.
Which keys leak most often?
In this sample, keys for AI services. Three of the four real findings were an OpenAI, an OpenRouter or a Gemini key used by code that calls the provider from the browser. The fix is the same each time: move the call to a server function and keep the key there.
Did you test whether the data in these apps is exposed?
No. We only read what every visitor's browser downloads. We sent nothing to any backend and tried no key. Whether a table answers a stranger can only be tested by its owner, or by a tool the owner authorised after proving the app is theirs.
Do you publish the list of apps?
No. The figures on this page are totals. We do not name an app, and what we saw in one app is only shared with the people who run it.
Why are your numbers lower than other vibe coding security statistics?
Because we count different things. Studies that query databases measure what leaks. We measured what the code shows, and we counted a key only after reading it in context. Eleven of our fifteen matches turned out to be placeholders, examples or library code.
Sources
- 1.Lovable partner directory, Lovable partners
- 2.Made with Lovable: project showcase, Made with Lovable
- 3.API keys, Supabase Docs
- 4.Securing your API, Supabase Docs
- 5.Using Gemini API keys, Google AI for Developers
- 6.Authentication, OpenRouter Docs
- 7.Security, Lovable Docs
- 8.Lovable: Many Apps Built on the Platform Expose Sensitive Data, Crissy Field
- 9.Statement on CVE-2025-48757, Matt Palmer