In short
- The Quick scan runs when the publish dialog opens. It checks tables without row level security, access rules that let everyone through, leaked-password protection, npm dependencies and MCP servers. It does not cover application code.
- The Deep scan reviews all application code in seven areas, including access control and unauthenticated endpoints. It does not run automatically while you work: start it from the Security view before each release.
- Running either scan is free. Fixes draw on 10 free fixes per account, each available again 24 hours after use. A security review asked in chat costs credits.
- Lovable's documentation says the built-in scanners perform static analysis and that these tools cannot guarantee complete security.
- A scan reads what you wrote. Whether a second account can read the first one's records is answered by a request to the published app, and that test completes the scan.
On this page
- What the Lovable security scan is
- What the Quick scan checks
- What the Deep scan checks
- How to run the scans and read the findings
- What the scans cannot see from inside the editor
- Check the published app yourself
- A routine that uses both
- What Keybrum adds to the Lovable scan, and what it does not
- Questions
- Sources
What the Lovable security scan is
Lovable builds a security scanner into every project. It has two levels, a Quick scan and a Deep scan, plus a review you can ask for in chat. All the facts on this page come from Lovable's security documentation as it reads on 13 November 2026.
Lovable deserves credit for it: the scan is free, it runs at the moment of publishing without being asked, and it speaks about the mistakes these apps really make. This page explains what each level reads, how to use the results, and where a scan made from inside the editor has to stop. For the wider picture of the platform, see the Lovable security guide.
| Quick scan | Deep scan | |
|---|---|---|
| When it runs | Automatically each time you publish, as the publish dialog opens. Also on demand | Only when you start it: Security view, workspace Security center, or by asking in chat |
| How long | Seconds | Longer: it runs in the background |
| Reads your application code | No | Yes, all of it |
| Database rules | Yes | Yes, it includes the Quick scan |
| Dependencies | Yes, npm packages with known vulnerabilities | Yes |
| Cost to run | Free | Free |
| Scheduled runs | Runs on publish | Enterprise plans only |
What the Quick scan checks
The Quick scan is a fixed set of checks that finishes in seconds. Lovable lists three parts.
- Database review. Tables without per-record access control (row level security), access rules that let everyone through, and leaked-password protection turned off. These checks only run for projects with a connected database.
- Dependency audit. Known vulnerabilities in your npm dependencies. Only vulnerabilities rated critical become findings, and Lovable leaves out some that it has confirmed cannot affect Lovable apps or that are unlikely to be exploited. The audit also runs when your dependency files change.
- MCP server check. An MCP server your app exposes without authentication.
The documentation is explicit about the limit: the Quick scan does not cover application code. An edge function that never checks who is calling, or a secret key written in a component, is outside it. That is the job of the Deep scan.
The Quick scan is the right check at the right moment. Missing row level security is the flaw behind CVE-2025-48757, in which 170 of 1,645 Lovable apps tested, about one in ten, let strangers read or write data. A check for exactly that, shown in the publish dialog, is the most useful place to put it.
What the Deep scan checks
The Deep scan reviews all your application code for issues specific to your app's logic, permissions and data, and it includes everything in the Quick scan. Lovable lists seven areas:
- Access control and authorization, including server code that bypasses database rules. It checks that privileged actions look at the caller's role as well as at whether they are signed in.
- Unauthenticated and abusable endpoints: functions or routes anyone can trigger, upload to, or use to send messages.
- Unsafe input and injection: input that reaches queries, commands, file paths, browsers, email, AI prompts or exported spreadsheets.
- Leaked secrets and credentials, including secrets in source code or a repository and access tokens that are easy to guess.
- Payments and billing: prices, fulfillment or paid features a customer can change or reach without paying.
- Authentication and account security: sign-in, account recovery, token checks.
- Exposed personal and sensitive data, including error messages and logs that reveal internal details.
That is a serious list. It covers the server-side mistakes a database check cannot see. The catch is in when it runs: the Deep scan does not start automatically while you work. Lovable names one exception, an app whose MCP integration allows access without sign-in, which starts a Deep scan in the background when published. In every other case, if you never click Run deep scan, your code has not been reviewed.
How to run the scans and read the findings
- 1
Open the Security view of the project
It has two cards, one per scan, with Run quick scan and Run deep scan. A card shows Up to date when its results already reflect the current version of your project.
- 2
Run the Deep scan before each release
It also refreshes outdated quick checks. You can ask for a scan in chat instead: Lovable runs the Quick scan, starts a Deep scan in the background and replies with the quick results.
- 3
Read by severity
Findings are grouped by security area and labelled Critical, Warning or Info, with the evidence behind each. Start with Critical. Read the evidence as well as the title.
- 4
Fix, or ignore with a reason
You can fix one finding, a selection, or everything with Try to fix all. A finding that does not apply can be ignored with a recorded reason. A table that is public on purpose, such as a product catalogue, is a fair case.
- 5
Scan again after the fix
A fix is a change to your app like any other. Run the scan again and wait for Up to date.
| Action | Cost |
|---|---|
| Running the Quick or Deep scan, from any entry point | Free |
| Fixing findings from the Security view or with Fix all in chat | 10 free fixes per account, each available again 24 hours after use, then credits |
| A security review asked in chat | Credits, as standard build usage. The scans it starts are free |
| Auto-fix during builds | Credits |
| Aikido penetration test (optional connection) | Billed by Aikido |
Two publishing behaviours are worth knowing. On a project with the built-in backend, clicking Publish with unresolved critical findings opens a Review security findings dialog, where you can send the findings to Lovable to fix or publish anyway. A workspace admin can go further with Block publishing with critical issues, which stops the publish until they are resolved.
What the scans cannot see from inside the editor
Lovable says it plainly: the built-in scanners perform static analysis by reading your code and configuration. Static analysis flags patterns that look risky. It does not send a request to your app and look at what comes back. The same page states that these tools cannot guarantee complete security, and recommends a professional review for apps that handle sensitive data. Lovable's page on its built-in backend calls the automated checks "not a full audit".
That leaves four things a scan from inside cannot settle.
- Whether a rule that exists is the right rule. The database review flags a table with no row level security and a rule that lets everyone through. A policy that compares the wrong column, or that only checks the caller is signed in, is a real condition. The Deep scan reasons about it in code. The proof is still a second account asking for the first one's record.
- What the published app answers. Strangers do not meet your project. They meet the version you last published, on its own address, with its own bundle. Only a request to that address shows what it returns to someone with no account.
- Whether a fix worked. After a fix, the scan tells you the pattern is gone. It cannot tell you the attack now fails, because it never ran the attack.
- What sits around the project. The DNS records of your custom domain, a server or an automation tool you run next to the app, a webhook secret set in Stripe's dashboard: none of it is in the code Lovable reads.
Lovable agrees with the principle. Its documentation presents a dynamic test as the complement of its scanners and offers one through an optional Aikido connection: AI agents interact with the running app and send real payloads, and the tests are billed by Aikido. If your workspace already uses Aikido, that is a good path. The point is the same whichever tool does it: read the code, then attack what is deployed.
Check the published app yourself
You can do a first outside test in ten minutes, on your own app, with no tool.
- 1
Open the published address in a private window
No session, no editor. Try the addresses of pages that should need a login. A page that renders data for a visitor is a finding.
- 2
Create two accounts
With the first, create a record: an order, a note, a profile. With the second, open the first one's record by its id, in the address bar or by replaying the request from the browser's Network tab. If it comes back, you have an IDOR.
- 3
Read your policies as they are
In Lovable, policies are under More, Database, Manage, Policies. If your project uses your own Supabase, the Supabase RLS checker gives you two read-only queries for the SQL editor and reviews the policies you paste.
- 4
Look inside the bundle
In the Network tab, open the JavaScript files your published app loads and paste them into the API key leak checker. A publishable key is expected. A secret key is not.
- 5
Call your AI and payment endpoints signed out
An AI function that answers a stranger spends your credits, see unprotected AI endpoints. A Stripe webhook that accepts an event without a valid signature can be told an order was paid.
A routine that uses both
- Before every publish: read the Quick scan line in the publish dialog. Do not publish over a Critical finding.
- Before every release that changes data or payments: run the Deep scan and wait for Up to date.
- Fix or ignore every finding, with a written reason for each ignore.
- After publishing: test the published address signed out and with two accounts.
- After every fix: run the scan again, then repeat the outside test that failed.
- Turn on leaked-password protection if your app has email and password sign-in.
What Keybrum adds to the Lovable scan, and what it does not
Keybrum is the outside half. It does not read your Lovable project. It attacks the published app the way a stranger would, and as two accounts it signs up. On the stack Lovable generates, its attacks try to read, insert and update rows in every table it finds, call database functions, list and upload to storage buckets, and subscribe to realtime channels. It sends a short test prompt to edge functions that look like AI endpoints to see whether a model answers without an account, posts an unsigned event to Stripe webhooks, looks for secret keys in the bundle and in rows anyone can read, and tries one account's records from the other.
Each finding carries the request that worked and a redacted piece of the answer. The fix comes as a prompt you can paste into Lovable's chat, or that a coding agent reads through Keybrum's MCP server. A finding closes only when the same attack fails on the published app, which is the check a static scan cannot make.
What Keybrum does not do: review your code line by line as the Deep scan does, audit your npm dependencies inside the editor, or judge business logic the way a person would. Delete access is never tested. It only attacks an app whose owner proved ownership. Use Lovable's scans for the inside and Keybrum for the outside. A one-time report costs €49: one app, one full attack run, retests for 7 days and the PDF report. Plans start at €29 a month excluding VAT for 5 apps and attack again on every deploy.
Questions
Is the Lovable security scan free?
Running the Quick scan and the Deep scan is free, from any entry point. Fixing findings draws on 10 free fixes per account, each available again 24 hours after use, then credits. A security review asked in chat is billed as standard build usage.
What is the difference between Lovable's Quick scan and Deep scan?
The Quick scan runs on publish, takes seconds and checks database rules, npm dependencies and exposed MCP servers. It does not cover application code. The Deep scan reviews all your code in seven areas, includes the Quick scan, and runs only when you start it.
Does Lovable's security scan run automatically?
The Quick scan does, each time you publish. The Deep scan does not run automatically while you work. Scheduled Deep scans across projects are available on Enterprise plans.
Is the Lovable security scan enough before launch?
It is the right first step, and Lovable's own documentation says its tools cannot guarantee complete security. The scans are static analysis. Add a test of the published app from outside, signed out and with two accounts, before you put real user data in it.
What is a Lovable security review?
Asking for a review in project chat gives an AI assessment of the project, covering areas such as XSS risks, input handling, authentication flaws and RLS policies. It also runs the Quick scan and starts a Deep scan. The chat costs credits, and the scans stay free.
Does Lovable offer penetration testing?
Through an optional connection to Aikido, set at the workspace level. Lovable's documentation describes it as dynamic analysis in which AI agents interact with the running app, and says it is billed by Aikido.
Sources
- 1.Security overview, Lovable Documentation
- 2.Lovable Cloud (built-in backend), Lovable Documentation
- 3.CVE-2025-48757, NIST National Vulnerability Database
- 4.Statement on CVE-2025-48757, Matt Palmer
- 5.Source Code Analysis Tools, OWASP