No scan without consent

Your AI-built web app — before you launch,
we inspect it in depth

Scanners read your source code. But incidents happen in what you deployed — API keys shipped into the browser, database credentials and dumps anyone can download, APIs with no auth. We look at the deployed reality. And we write down even what we couldn't verify.

400+exposed secrets (API keys, tokens) found across ~1,400 live vibe-coded apps
175PII exposures in the same scan — including bank-account and other sensitive data
45%of AI-generated code shipped an OWASP Top 10 security flaw

Sources: Escape.tech — State of Security of Vibe Coded Apps (2025, ~1,400 apps, 2,038 critical vulns) · Veracode 2025 GenAI Code Security Report (100+ LLMs) · industry figures, not measurements of your app

🔒 The one promise we keep

We scan nothing until you prove you control the domain. Not an "I agree" checkbox — a proof only you can produce. No one can enter your domain and have it scanned.

SSH internal audits run only with a separate explicit request and granted access. Results go to you alone and are never published. Any secrets found are kept as fingerprints only — the originals are not stored.

HOW IT WORKS

Three steps — and the second is the point

The second step — proof of consent — is what makes this service safe.

1

Tell us the domain

Enter the web app's address and we issue a unique token bound to your request alone.

2

Prove control

Place the token at /.well-known/star365-audit-consent.txt or add it as a DNS TXT record. Being able to put it there is itself proof that you own the domain.

3

We audit, you get a receipt

We audit only after verifying the token. Pass, fail (warn/critical) — and the items we couldn't verify — all in a tamper-proof receipt.

TRY IT

Try the consent flow now

The real audit runs on our server, but you can walk through the request and token flow right here.

star365 Deploy Audit Desk
This page does not run any real scan. Probing someone else's server from the browser is itself risky. Real audits run only on our server, after consent is verified.

WHAT WE CHECK

The 20 things we check

This list is generated from what the audit engine declares — not typed by hand. If the engine changes, this table changes with it. Each item gets one of three verdicts: pass, fail, or undetermined.

Reachability

Does the site respond. If we cannot read it, we judge nothing else.

reachable

Client-side secrets

Whether API keys or other secrets ship inside the HTML and JS delivered to browsers.

client_secrets

Exposed source maps

Whether a public source map (.map or inline data-URI) lets your original source be reconstructed from the bundle — even with no secret in the bundle, pricing logic, internal flows and comments are exposed. This is what external reverse-engineering targets.

source_maps

Exposed sensitive paths

Whether paths like .env or .git are reachable from outside.

exposed_paths

Security headers

Whether the four main security headers such as CSP and HSTS are set.

security_headers

Soft-404

Whether missing URLs return 200 — machines then read typo URLs as real pages.

soft_404

Cookie security flags

Whether cookies on an https site are missing Secure — they can leak over a plaintext request.

cookie_flags

Robots self-block

Whether robots.txt blocks this public page from every crawler. Having no robots.txt is fine.

robots_sanity

Body without JS

Whether the HTML served without running JavaScript already has content — crawlers and link previews do not run JS.

server_rendered_body

Runtime console errors

We open it in a real browser and watch for console errors.

runtime_errors

Broken assets

Whether scripts, images or other assets fail to load.

broken_assets

Mixed content

Whether an https page pulls http resources.

mixed_content

Actually renders

Whether real content paints — a 200 can still be a blank screen.

renders_content

Mobile overflow

Whether narrow screens get a horizontal scrollbar.

mobile_overflow

Dead internal links

We follow internal links to see whether they actually open.

internal_links

Readability

We measure font size and contrast on the rendered page — 12px minimum, WCAG AA (4.5:1 body, 3:1 large). If the background cannot be determined we do not judge.

readability

Private-network calls

Whether the public page calls localhost or private IPs — a dev API address left in the build fails for every visitor.

private_network_calls

Unauthenticated API data

Whether common API paths hand out user records (email, phone…) without login — checked with GET only, values never stored.

open_api_data

Supabase RLS

If the bundle ships a Supabase URL and anon key, it tries one GET per table the bundle already calls, using the anon key, to see whether RLS is on. Row values are never read; only column names are.

supabase_rls

Software version disclosure

Checks whether the Server and X-Powered-By headers or a generator tag reveal a version string such as nginx/1.24.0. A version is not itself a flaw, but it hands attackers a shortlist. We do not judge whether it is vulnerable.

version_disclosure

SAMPLE REPORT

This is what the receipt looks like

A real audit example. Not just the passes — we also write down what we couldn't see and what to fix.

example-app.com 2026-09-19 · External audit (consent verified)
example-app.com 2026-09-19 · Internal audit (SSH consent)
Each verdict is one of pass / fail / undetermined, and failures carry a severity (warn/critical). Not hiding “undetermined” as a pass is the whole point of this receipt — that's exactly why a free scanner's green light can be dangerous.

WHY US

Why a free scanner isn't enough

Snyk and Semgrep's free tiers are excellent. But they read your source code.

Free scanner (source-based)

  • Known vulnerable patterns in source
  • Dependency CVEs
  • Ends at "N issues found" — never says what it missed
  • Blind to deploy artifacts and runtime config

Us (deployed-reality based)

  • Keys in the browser bundle — we look at what's actually served
  • Downloadable DB dumps and sensitive paths — we actually request them
  • We flag what we couldn't check as "undetermined"
  • With consent, SSH internal audit — permissions, firewall, config

FAQ

Frequently asked questions

So that people and AI answer-engines read the same answers, we keep the common questions right here.

What do you audit?

Not the source code — the deployed reality. API keys shipped to the browser, databases open from outside, unauthenticated APIs — and we also open it in a real browser to catch console errors, broken assets, mobile horizontal overflow and dead links. The failures that happen after you deploy, seen from outside.

How do you obtain consent?

Not with a checkbox, but with proof. We issue a token; the audit begins only once you prove ownership by placing it at a designated path on the domain or as a DNS TXT record. We re-verify right before scanning.

Is the audit safe?

External audits use read-only GET requests only. No injection, no brute force, no overload. The result receipt is kept as a tamper-evident hash chain.

What do the results look like?

Each verdict is one of pass / fail / undetermined, and failures carry a severity (warn/critical). We never fold an unread item into a pass or a zero — we write down even what we couldn't verify.

Does it cost anything?

External audits are free. If you like, voluntary donations (non-custodial: USDT, USDC, BTC, ETH, BNB) are welcome. SSH internal audits and continuous monitoring are arranged after a consultation, based on scope.

Related: Request an audit · llms.txt · Operator star365 · Trading fleet metaquant · Sitemap