Check your own app — free, in about a minute.
v0 generates the code; the deployed site is what attackers see. The mini-scan checks that live site from the outside — headers, exposed files, keys leaked into the client bundle, and backend rules. You get a score and the finding titles — no account, no card.
Run the free mini-scan →v0 generates some of the cleanest-looking Next.js code you'll ever get from a prompt. Components land styled, the layout works, and deploying to Vercel takes seconds. But "it renders beautifully" and "it's safe to put on the internet" are different statements. Here's what v0-generated Next.js apps typically get wrong, and how to verify yours before you ship.
v0's strength is UI. Its weakness — shared by every AI code generator — is that it optimizes for working, and working code that never checks who's calling still works. The exposures below show up in v0 apps over and over.
In Next.js, the rule is simple: variables prefixed with NEXT_PUBLIC_ are baked into the JavaScript sent to every visitor's browser. Everything else stays server-side. v0 doesn't always respect that boundary. It will take a Stripe secret key, a Resend API key, or an OpenAI key you pasted in and wire it into client components or NEXT_PUBLIC_-prefixed variables to make the demo work.
Test it:
# Find your client bundles
curl -s https://your-app.com | grep -o '/_next/static/[^"]*\.js' | head -3
Then fetch the largest chunk and grep for key patterns:
curl -s "https://your-app.com/_next/static/chunks/MAIN-CHUNK.js" \
| grep -oiE 'sk_live_[a-z0-9]+|sk-test[a-z0-9_-]+|AIza[a-z0-9_-]{35}|re_[a-z0-9]+' | head
If a live secret key shows up, rotate it now. It has been public since deploy.
Fix: Server-only keys go in plain env vars (no NEXT_PUBLIC_ prefix) and are used exclusively in Server Components, Route Handlers, or Server Actions. The client should never import them — not even transitively through a shared module.
v0 loves generating app/api/* route handlers. It rarely generates the auth check that should wrap them. A handler like this is typical AI output:
// app/api/users/route.ts — generated, no auth check
export async function GET() {
const users = await db.query.users.findMany();
return Response.json(users);
}
It works in the demo because you're logged in. It also works for anyone else on the internet.
Test it — in a private/incognito window, logged out:
# Enumerate the routes your app actually calls (check the Network tab first)
curl -s https://your-app.com/api/users | head -c 500
curl -s https://your-app.com/api/orders | head -c 500
curl -s https://your-app.com/api/admin/stats | head -c 500
200 with data while logged out = unprotected endpoint. Test POST/PUT/DELETE too — read-only exposure is bad, but unauthenticated writes are worse:
curl -s -X DELETE https://your-app.com/api/users/123 -o /dev/null -w "%{http_code}\n"
(Use a test record you created for this purpose, not real data.)
Fix: Every route handler that touches user data must verify the session server-side before doing anything. In Next.js that means checking the session in the handler itself (via your auth library's server-side session check), not relying on middleware redirects or client-side guards — middleware can be bypassed or misconfigured, and client-side checks are invisible to curl.
v0 increasingly generates Server Actions. These are powerful — and they're directly callable by anyone who can read your client bundle. An action like deleteAccount(userId) that trusts the userId it receives is an IDOR waiting to happen: an attacker just calls it with someone else's ID.
Test it: Open DevTools, find the Server Action call in the Network tab (they POST to the page URL with a special header), and replay it with a modified ID while logged in as a low-privilege test user. If you can act on another user's data, the action trusts input it shouldn't.
Fix: Server Actions must derive identity from the session, never from arguments. The action should look up "who is calling" server-side and ignore any user ID the client sends — or verify the caller owns the record being touched.
A common v0 pattern: a middleware.ts that redirects unauthenticated users away from /dashboard. That protects the page render. It does not protect the API routes or Server Actions that page calls, unless the middleware matcher explicitly covers them — and matchers are easy to get wrong (missing /api/:path*, trailing-slash mismatches, static-asset exclusions that swallow routes).
Test it: Don't just load the dashboard page logged out — curl its underlying API routes logged out (see Exposure 2). Page-level redirects passing while API routes return data is the classic gap.
Fix: Treat middleware as UX, not security. Put the auth check in the route handler or Server Action itself. Defense in depth is good; middleware-only is not.
AI-generated code loves detailed error responses — full Prisma/Drizzle error objects, stack traces, "connection failed to postgres://..." messages. In development that's helpful. In production it's a map of your internals.
Test it:
# Trigger errors and read what comes back
curl -s https://your-app.com/api/users/not-a-real-id | head -c 800
curl -s -X POST https://your-app.com/api/checkout \
-H "Content-Type: application/json" -d '{"bad": json}' | head -c 800
If you see stack traces, SQL fragments, file paths, or connection strings, your error handling is leaking.
Fix: In production, catch errors at the route boundary and return generic messages ({ "error": "Something went wrong" }). Log the details server-side where only you can see them.
Vercel doesn't add these for you by default:
curl -sI https://your-app.com | grep -iE 'content-security-policy|x-content-type-options|strict-transport'
Add them in next.config.js headers or middleware.ts. It's a one-time config change that blocks entire attack classes.
/api/* — then secure the handlers anyway (Exposure 4)Do this after every major AI-assisted change, not just the first deploy. v0 iterates fast, and a "quick cleanup" refactor is exactly how an auth check quietly disappears.
Manually curling every route and replaying every Server Action gets old fast — and the route you forget to test is usually the one that matters. PreShipIt does the attacker-style probing for you: paste your app's URL, attest that you own it, and get a plain-English prioritized report of what's reachable and exposed, before strangers find it.
Don't want to do it by hand? PreShipIt scans your app from the outside for $29, one time.
Note on scope: PreShipIt runs an outside-in, unauthenticated scan of the single host you submit. It doesn't test anything behind a login, doesn't review your source code, and doesn't guarantee your app is secure — it shows you what an unauthenticated visitor can see and reach, so you can fix it first.
The PreShipIt Brief — a short weekly email for people shipping vibe-coded apps: the week's important vulnerabilities and launch-safety checks, in plain English.
New and free. Double opt-in: we email you a confirmation link before anything else arrives. Unsubscribe any time.
Check your own app — free, in about a minute.
v0 generates the code; the deployed site is what attackers see. The mini-scan checks that live site from the outside — headers, exposed files, keys leaked into the client bundle, and backend rules. You get a score and the finding titles — no account, no card.
Run the free mini-scan →← Back home · Run a free mini-scan · Scan my app — $29 · See a sample report