Check your own app — free, in about a minute.
Your Replit app is already on a public URL — this checks that URL from the outside, where it counts: headers, exposed files, backend rules and leaked keys your repl's code view never shows you. You get a score and the finding titles — no account, no card.
Run the free mini-scan →Replit is the fastest path from prompt to public URL: describe the app, let the AI agent build it, hit Deploy, and you're live. That convenience comes with a security posture designed for frictionless building — which means several defaults that are fine for a prototype and dangerous for anything real. Here's what Replit-deployed apps typically expose and how to check yours.
Unlike a static host, a Replit Deployment runs your actual repl — a live process with open ports, a filesystem, and environment state. The AI agent that built your app had broad latitude: it installed packages, opened ports, wrote config files, and stored secrets wherever made the build pass. Your job is to verify what it left behind.
Replit has a Secrets panel (environment variables), and the AI agent knows about it. But agents also do what agents do: hardcode keys "temporarily" to get something working, write them into config files, or echo them into logs. And when you use Replit's "publish" flow, what's in the code is what's deployed.
Test it — check the deployed app, not just the editor:
# Grab the main JS bundle from your deployed URL and grep for key patterns
curl -s https://your-app.replit.app | grep -o 'src="[^"]*\.js"' | head -3
curl -s https://your-app.replit.app/assets/index-xyz.js \
| grep -oiE 'sk_live_[a-z0-9]+|AIza[a-z0-9_-]{35}|AKIA[0-9A-Z]{16}|xox[bap]-[a-zA-Z0-9-]+' | head
Then check your repl's git history and any config files for committed secrets:
# In the Replit shell
git log -p | grep -iE 'sk_live|api_key|secret|password' | head -20
grep -riE 'sk_live|api_key' --include='*.json' --include='*.js' --include='*.ts' . 2>/dev/null | grep -v node_modules | head
Fix: Move every secret into the Secrets panel (environment variables), reference them via process.env / os.environ only, and rotate anything that was ever hardcoded or committed. Check .replit and config files for anything the agent pasted in.
A Replit deployment exposes whatever your repl listens on. AI agents commonly open extra ports — a dev server on 3000, an API on 8000, a database admin panel, a debug interface — and forget to close them. Replit's port configuration may expose these publicly.
Test it: In your repl, open the Shell and see what's actually listening:
ss -tlnp 2>/dev/null || netstat -tlnp 2>/dev/null
Compare that against what you intend to expose (usually one web port). Anything else — database ports, dev servers, admin UIs — should not be reachable.
Then check from the outside. Replit deployments typically serve on ports 80/443, but verify your .replit run configuration and the Deployments panel to confirm which ports are mapped publicly.
Fix: Bind internal services to localhost only (127.0.0.1, not 0.0.0.0), remove dev servers and admin panels from the deployment configuration, and confirm the Deployments panel exposes exactly one public port.
.replit File and Repl Visibility AI-built projects sometimes get created with repl visibility set more openly than intended, and forks or "remixes" can carry your code (minus secrets, but including everything else: API structure, hardcoded test credentials, internal URLs) to other users.Test it: Check your repl's privacy settings — confirm the repl is private. Search your code for test credentials the agent may have created:
grep -riE 'admin.*password|test.*123|password.*=.*["\x27][^"\x27]+["\x27]' --include='*.js' --include='*.ts' --include='*.py' . 2>/dev/null | grep -v node_modules | head
Test accounts with weak passwords (admin/admin, test/test123) that the AI created for demo purposes are a classic find.
Fix: Set the repl to private, delete or disable demo accounts before deploying (or give them unguessable passwords and document them), and treat anything in the repl as potentially visible — keep secrets in the Secrets panel only.
Same story as every AI builder: the agent wired up endpoints that work, not endpoints that check identity. Replit's agent is particularly prone to building Express/FastAPI/Flask routes with zero auth because nothing in its instructions says otherwise.
Test it — logged out, from your terminal. First find the routes:
# Find the routes (check your main server file for app.get/app.post definitions)
grep -rhoE "(app|router)\.(get|post|put|delete)\(['\"][^'\"]+" --include='*.js' --include='*.ts' --include='*.py' . 2>/dev/null | grep -v node_modules | sort -u | head -20
# Then hit each one with no credentials
curl -s https://your-app.replit.app/api/users | head -c 500
curl -s -X POST https://your-app.replit.app/api/data \
-H "Content-Type: application/json" -d '{"probe": true}' | head -c 500
Fix: Add authentication middleware to every route that touches data or performs actions. Frontend login screens don't count — the check must run on the server for each request.
Replit's "always on" keeps your repl running, and Deployments create versioned releases. Two risks: (1) an old deployment with known vulnerabilities stays live at its URL after you ship a fix to a new one — check the Deployments panel and retire old versions; (2) the always-on repl keeps dev-only behavior (verbose logging, debug endpoints) running indefinitely.
Test it: List your deployments and hit the previous version's URL. If the old version still responds, it's still attackable. Also check console output for secrets — agents love to console.log tokens "for debugging."
Fix: Retire old deployments when you ship, strip debug logging before deploying, and treat console output as public — never log tokens, keys, or user data.
curl -sI https://your-app.replit.app | grep -iE 'content-security-policy|x-content-type-options|strict-transport'
AI-generated Express/Flask/FastAPI servers almost never include rate limiting — hammer your login endpoint with 30 rapid requests and see whether you get throttled or just keep getting 200s.
Fix: Add helmet (Express), slowapi/flask-limiter, or your framework's equivalent. One middleware, enormous difference.
Replit's speed is the point — just don't let the deploy step outrun the verify step.
Walking every route, port, and bundle by hand is exactly the kind of tedious work that gets skipped — and the exposure you skip checking is the one that bites. PreShipIt probes your deployed app from the outside the way an attacker would: no login, no source access, just your public URL. You get a plain-English prioritized report of what's reachable and what to fix.
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 — paste your URL and attest that you own the app. 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.
Your Replit app is already on a public URL — this checks that URL from the outside, where it counts: headers, exposed files, backend rules and leaked keys your repl's code view never shows you. 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