In short
- Security Advisor runs lints from Supabase's open source linter, splinter, which uses SQL queries to identify common database schema issues. Findings have three levels: ERROR, WARN and INFO.
- The most serious lint is
rls_disabled_in_public. Supabase's own text: anyone with your project URL can read, edit and delete all data in the table. - A finding can be intentional. Supabase's documentation says to check each one against your intended schema and access model. A public product catalogue is allowed to be readable.
- The always-true policy lint looks for conditions such as
USING (true). A policy that only checks the caller is signed in is a real condition, and it still lets every user read every row. - A clean Advisor means no known bad pattern in the schema. Run a signed-out request and a two-account test on your own app to see what your policies actually return.
On this page
What is Supabase Security Advisor?
Security Advisor is a page in the Supabase dashboard that lists security problems found in your database. Supabase's documentation calls its Advisors "deterministic checks that ship with the platform". There are three of them: Security Advisor, Performance Advisor and Health Advisor. Each check is called a lint and has a number and a name, such as 0013_rls_disabled_in_public.
The lints come from splinter, Supabase's open source Postgres linter. Its README says it "uses SQL queries to identify common database schema issues". That sentence is the key to reading the Advisor: it queries your database's catalog, the tables that describe your tables, policies, views and functions. It is fast, free and exact about what it looks for.
You can run it four ways, all listed in the documentation:
- Dashboard: the Security Advisor page of your project.
- CLI:
supabase db advisors. - MCP: the Supabase MCP server's
get_advisorstool, withtypeset tosecurity. A coding agent such as Cursor or Claude Code can call it after each migration. - Management API: the security advisor endpoint, for a pipeline.
Supabase's shared responsibility model is clear about who does what next: Supabase provides security alerts through Security Advisor, and applying the recommendations is your responsibility.
What Security Advisor checks: the lints that matter
The documentation lists 30 numbered lints today, across security and performance, plus health checks on error rates. These are the security ones you are most likely to meet in an app built with Lovable, Bolt, Cursor or Claude Code.
| Lint | Level | What it means | First fix |
|---|---|---|---|
0013_rls_disabled_in_public | ERROR | A table in the public schema has no row level security. Anyone with the project URL can read, edit and delete its data | Enable RLS, then write policies |
0023_sensitive_columns_exposed | ERROR | A table reachable through the API, without RLS, has columns named like password, token or api_key | Enable RLS, or move the columns |
0010_security_definer_view | ERROR | A view in public runs with its creator's rights and bypasses RLS | Set security_invoker = true on the view |
0002_auth_users_exposed | ERROR | A view exposes auth.users data through the API | Drop it, or expose only the columns you need from a profile table |
0015_rls_references_user_metadata | ERROR | A policy trusts user_metadata, which the user can edit | Use data the user cannot change |
0024_permissive_rls_policy | WARN | A policy's condition is always true, such as USING (true) | Write a real condition, such as an owner check |
0028 and 0029, security definer function executable | WARN | A SECURITY DEFINER function can be called through the API by anon or by any signed-in user, and runs as its owner | Revoke EXECUTE, or switch to SECURITY INVOKER |
0025_public_bucket_allows_listing | WARN | A public storage bucket has a broad SELECT policy that makes its contents listable | Narrow the policy |
0011_function_search_path_mutable | WARN | A function has no fixed search_path | Set search_path = '' on the function |
0008_rls_enabled_no_policy | INFO | RLS is on with no policy, so the API returns no data | Not a leak. Add policies if the app needs the table |
0007_policy_exists_rls_disabled | INFO | Policies exist and have no effect because RLS is off | Enable RLS: the table is open until you do |
How to read a finding, and what to do with it
- 1
Start with ERROR
The ERROR lints describe states where data is reachable or a trust boundary is broken. Fix them before anything else, and before you put real users in the app.
- 2
Ask whether it is intentional
Supabase's documentation says some findings may be intentional and tells you to check them against your intended schema and access model. For the always-true policy lint it names the fair cases: public read-only tables such as blog posts or product catalogues. A public
orderstable is not one of them. - 3
Fix in a migration
Make the change in a migration file, so the fix is in your repository and survives a rebuild. If you let a coding agent write it, read the SQL before you run it.
- 4
Run the Advisor again
The lint should clear. Health findings can take a while to clear, because they measure error rates over time.
- 5
Then test the behaviour
A cleared lint means the pattern is gone. The last section of this page shows how to check what a real request returns.
The common fixes are short. Replace the table, view and function names with yours:
-- 0013: enable RLS, then add an owner policy
alter table public.orders enable row level security;
create policy "owners read their orders"
on public.orders for select
to authenticated
using ((select auth.uid()) = user_id);
-- 0010: make a view obey the RLS of its tables (Postgres 15 and later)
alter view public.order_summary set (security_invoker = true);
-- 0011: fix the search path of a function
alter function public.my_function() set search_path = '';
-- 0028: stop signed-out callers from running a security definer function
revoke execute on function public.my_function() from public, anon;The Supabase RLS guide has complete policies for select, insert, update and delete, and the storage security guide covers buckets.
What Security Advisor cannot tell you
The Advisor is a linter. It recognises shapes in the schema. That is its strength, because it never guesses, and its limit, because a schema with no known bad shape can still hand out the wrong rows.
- Whether a policy that exists is right for your data. By its description, the always-true lint detects
USING (true),USING (1=1)or a missing clause. A policy such asusing (auth.uid() is not null)is a real condition. It lets every signed-in user read every row, and with open sign-up anyone can become a signed-in user in a minute. The same goes for a policy that compares the wrong column. - What a second account can read. The Advisor does not sign in. It cannot create user A and user B and ask for A's record as B. That is the test that finds an IDOR.
- What the function does once it is called. The lints tell you a
SECURITY DEFINERfunction is callable. Whether it checks the caller's rights inside is in its body, which you have to read. - Anything outside the database. A
service_roleor secret key in your JavaScript bundle, an edge function that never checks the caller, a server route that uses the secret key and skips RLS, a Stripe webhook without a signature check. - Schemas it was not told about. The splinter README notes that some lints only report objects exposed through the Data API, and default to the
publicschema when the exposed schemas setting is unset.
Supabase says as much in its own RLS documentation, where it recommends writing tests for policies: "Until the suite passes, you don't know whether the policies do what you intended." The Advisor tells you a policy is there. Only a test tells you it returns the right rows.
The live test that completes it
Three checks on your own project close the gap. The first is the question a stranger asks, signed out, with the public key your app already ships:
# Your own project and your own public key only.
curl "https://YOUR-PROJECT.supabase.co/rest/v1/orders?select=*&limit=1" \
-H "apikey: YOUR_PUBLISHABLE_KEY"The second runs in the SQL editor and plays a signed-in user against your policies. Supabase's RLS documentation gives the method: switch role and identity with set local role and set local request.jwt.claim.sub.
begin;
set local role authenticated;
set local request.jwt.claim.sub = 'UUID-OF-USER-B';
-- As user B: how many orders can I see, and whose are they?
select user_id, count(*) from public.orders group by user_id;
rollback;The third is the same test through the app. Create two accounts, create a record with the first, and request it with the second by its id. Then try to change it. Read access and write access are separate policies, and a table often gets one right and the other wrong.
- Security Advisor shows no ERROR, and no finding you cannot explain.
- The signed-out curl returns nothing on every table with user data.
- The impersonation query returns only user B's rows.
- User B cannot read or update user A's record through the app.
- No
service_roleor secret key appears in the JavaScript your app serves. The Supabase key checker tells you which kind a key is. - The checks are repeated after every migration, not once.
What Keybrum tests on a Supabase app, and what it leaves to the Advisor
Keybrum runs the live half automatically. It finds your Supabase project from your published app, then attacks it as a stranger and as two accounts it signs up. Its Supabase attacks try to read, insert and update rows in every table it finds, call your database functions, list and upload to storage buckets, fetch files at known paths, and subscribe to realtime channels. It also looks for secret keys in rows anyone can read, tries to raise an account's own role, checks whether sign-in redirects accept any address, tests the JWT secret against weak values, and sends a short prompt to edge functions that look like AI endpoints. It searches the bundle for a service_role or secret key.
Each finding carries the request that worked and one redacted row as proof, with the fix for your coding agent through Keybrum's MCP server. A finding closes only when the same attack fails. On a plan the attacks run again on every deploy, so a policy loosened next week is reported next week.
What Keybrum does not do: it sees your database only from outside, so it does not report what cannot be reached from there, such as a mutable search_path, an outdated extension or the performance lints. Delete access is never tested. It tests the tables and functions it can find from outside, and one that nothing reveals may be missed. Keep the Advisor for the schema and use the two together. Keybrum only attacks apps whose owner proved ownership. A one-time report costs €49, and plans start at €29 a month excluding VAT for 5 apps.
Questions
Where is Security Advisor in the Supabase dashboard?
It is one of the Advisors pages of your project, next to Performance Advisor and Health Advisor. You can also run the same checks with supabase db advisors in the CLI, with the get_advisors tool of the Supabase MCP server, or through the Management API.
Is Supabase Security Advisor free?
The Advisors are described in Supabase's documentation as deterministic checks that ship with the platform, and the linter behind them, splinter, is open source under the PostgreSQL licence. You can run its single SQL query against your own database.
What does "RLS disabled in public" mean?
A table in the public schema, exposed through Supabase's APIs, has row level security turned off. Supabase's text for this lint says anyone with your project URL can read, edit and delete all data in the table. Enable RLS on the table, then create policies.
Can I ignore a Security Advisor warning?
Sometimes. Supabase says some findings may be intentional, for example an always-true read policy on a public product catalogue. Decide table by table, write the reason down, and never ignore a finding on a table that holds user data without testing it.
Security Advisor shows no issues. Is my Supabase app safe?
It means no known bad pattern was found in the schema. It does not show that your policies return the right rows to the right user, and it does not look at keys in your frontend or at your edge functions. Test the live app signed out and with two accounts.
Does Security Advisor check my RLS policies?
It checks their shape: missing policies, always-true conditions, policies that rely on user-editable metadata, several permissive policies on one table. It does not run them as a user. Whether a policy matches your data model is yours to test.
Sources
- 1.Database Advisors, Supabase Docs
- 2.splinter: Supabase Postgres linter, Supabase
- 3.Row Level Security, Supabase Docs
- 4.Shared responsibility model, Supabase Docs
- 5.Production checklist, Supabase Docs
- 6.A01:2025 Broken Access Control, OWASP