All 33 StackSecured scan engines, explained
Every check StackSecured runs against your app, grouped by what it actually does and what it takes to unlock it — from passive header reads to real offensive payloads, to the SEO, AEO, and GEO signals that decide whether AI search engines can find and recommend you at all.
Passive parsing of JS bundles, HTML source, DNS records, and headers. Zero data mutation, read-only requests, included in every scan without pre-verification — including the free tier.
Genuinely active probes — XSS/SQLi injection, spoofed webhooks, unauthenticated database queries. Gated strictly behind domain ownership verification (DNS or HTML token) to prevent misuse as a free attack proxy.
Verified-only: the offensive security suite
These six only run once you've proven you control the domain being scanned.
Attack Probe (XSS / SQLi / Auth Burst)
Fires real offensive XSS and SQLi payload injections alongside authentication-endpoint request bursts against live targets. Strictly gated behind domain ownership to prevent misuse as a free attack proxy.
Authorization (BOLA / IDOR)
Tests ID-bearing routes (e.g. /api/orders/123) and discovered admin routes for unauthenticated access. Does not claim full cross-user BOLA testing, which would require faking multi-tenant identities.
Supabase RLS (Row Level Security)
Attempts unauthenticated SELECT queries against every discovered table to test whether RLS policies genuinely block read access. Deliberately read-only — never mutates data or exposes row contents in reports.
SSRF Detection
Discovers URL-fetching endpoints (image proxies, link previews) and probes them with canary targets like cloud metadata IPs and file:// URLs to detect internal network exposure.
Webhook Signature Verification
Sends spoofed webhook payloads — e.g. a fake "payment succeeded" event — with deliberately wrong or missing signatures to confirm whether the endpoint enforces cryptographic signature verification.
File Upload Authentication
Dispatches multipart POST requests with no attached files to upload endpoints, verifying that authentication gating happens before payload processing — without ever storing files on target systems.
Security engines
Seventeen always-run checks covering secrets, headers, sessions, and the low-level protocol edge cases most scanners skip.
API Key Exposure
Scans client JS bundles for private secrets — OpenAI, Anthropic, Stripe secret, Supabase service-role keys. Ignores intentional public keys (Supabase anon, Stripe publishable) to prevent false alarms.
Config File Exposure
Probes paths like .env, .git/config, and wp-config.php. Uses response fingerprinting rather than status codes alone to prevent false positives from SPA fallback pages.
Next.js Data Leak (__NEXT_DATA__)
Parses the JSON hydration blob embedded in Next.js HTML for server-side secrets, database connection strings, and personal data accidentally passed directly to the client.
Firebase Security
Detects Firebase client configs in page source and tests unauthenticated read access against Firestore, Realtime Database, and default Storage buckets to catch unconfigured security rules.
CORS Configuration
Sends spoofed origin headers to detect wildcard, reflective, or credentialed CORS misconfigurations that let external sites read authenticated response data.
Security Headers
Evaluates HSTS, CSP, and X-Frame-Options on the homepage, with automatic retry logic to eliminate false alarms caused by server cold-start delays.
Admin Route Exposure
Probes sensitive backend API endpoints (e.g. /api/admin, /api/users) while deliberately ignoring page routes that safely redirect to a sign-in screen.
GraphQL Security
Probes GraphQL paths for unauthenticated introspection (full schema leakage) and tests whether query batching is enabled, which can be used to bypass per-request rate limits.
Cookie Security
Parses live Set-Cookie response directives to confirm session tokens enforce HttpOnly, Secure, and proper SameSite attributes.
Source Map Exposure
Audits production Next.js build paths for exposed .js.map files, which let an external actor reconstruct original, unminified source code.
API Documentation Exposure
Checks standard Swagger/OpenAPI paths and verifies response content signatures to flag publicly accessible API documentation that maps internal endpoints.
HTTP Method / TRACE
Dispatches low-level TCP/socket TRACE requests directly, bypassing a Node fetch() runtime restriction that silently fails to detect TRACE exposure on standard engines.
Error Disclosure
Triggers error conditions to check for leaked stack traces, framework versions, or raw database error messages (Prisma, Postgres).
Open Redirect
Tests parameters like redirect, next, and url against spoofed domains to catch unvalidated redirects that get used in phishing campaigns.
Auth Rate Limiting
Fires a burst of concurrent requests at auth endpoints (/login, /signin) to verify credential-stuffing throttling is actually enforced, not just configured.
JWT / Session Security
Decodes tokens found in cookies and client storage; flags alg:"none" exploits, missing expiry, and session tokens stored somewhere they shouldn't be.
Active Probe (debug endpoints)
Safely checks for publicly accessible debug and diagnostic endpoints without needing domain verification. Its offensive counterpart — real XSS/SQLi payloads — is gated separately as the verified-only Attack Probe engine above.
Advanced analysis
Two beta engines aimed specifically at patterns common in AI-generated code.
AI-Code Risk (beta)
A static-pattern scan built specifically for code generated by LLM assistants — looking for client-side-only authorization checks and direct client-side database mutation calls with no server gate behind them. Findings are capped at Medium severity and phrased as advisory, because an unauthenticated scan can't prove intent, only surface a pattern.
Business Logic Signals
Flags observable client-side business logic anomalies worth human review — like client-controlled pricing fields, or quantity inputs that accept negative numbers. Explicitly low-confidence: it surfaces what's worth a second look, not a confirmed exploit.
Infrastructure & domain hygiene
Five engines that look past your app code to the DNS, TLS, and dependency layer underneath it.
Technology + CVE Lookup
Fingerprints your tech stack and queries OSV.dev and curated CVE databases. Assigns full severity only when a version number is actually confirmed, never guessed.
Wayback Machine Exposure
Queries the Internet Archive's CDX API for archived secret files — .env, git config — that may still sit in permanent public history even after you've removed them from your live site.
Email Security (SPF / DMARC / DKIM / DNSSEC)
Resolves DNS records at the apex domain — never www. — to verify your email anti-spoofing coverage, and that each record is actually valid, not just present.
TLS Certificate Expiry
Opens a raw HTTPS connection to inspect the SSL/TLS peer certificate's expiration date directly, with handling to avoid crashing on connection errors.
Subdomain Takeover
Matches CNAME records against known abandoned third-party provider signatures (GitHub Pages, S3, Vercel) to flag dangling hosts an attacker could claim.
Visibility: SEO, AEO & GEO
Three engines included free with every scan — because getting found by search engines and AI assistants is a launch requirement, not a nice-to-have.
SEO Signals
Audits traditional search fundamentals — titles, meta descriptions, Open Graph tags, canonical tags, mobile viewport configuration — and robots.txt syntax, to catch an accidental Disallow: / blocking every crawler.
AEO — Answer Engine Optimization
Evaluates the structured data (JSON-LD, FAQ schema, HowTo schema) and verified contact pages that conversational AI engines like ChatGPT and Perplexity look for before citing a product directly in an answer.
GEO — Generative Engine Optimization
Checks the entity trust signals — Organization schema, Person/founder schema, linked social profiles, privacy and terms pages — that LLM-powered search models weigh when deciding whether to recommend a brand at all.
See all 33 engines run against your own app
StackSecured runs every always-run engine free, in about 30 seconds — verify domain ownership to unlock the six offensive engines too.
Run a free scanCommon questions
What's the difference between "Always-Run" and "Verified-Only" engines?
+
Always-Run engines (27 of the 33) are passive, non-destructive checks — reading HTML, response headers, DNS records, and public archives. They're safe to run against any URL without proof of ownership. Verified-Only engines (6) are genuinely active: real XSS/SQLi payloads, spoofed webhook events, unauthenticated database queries. Those only fire once you've proven domain control via a DNS or HTML token, so the scanner can't be used as an anonymous attack proxy against a site you don't own.
Does StackSecured ever attack a site without permission?
+
No. The six offensive engines — Attack Probe, Authorization, Supabase RLS, SSRF, Webhook Signature Verification, and File Upload Authentication — are hard-gated behind domain ownership verification. Until that check passes, only the 27 passive engines run.
How reliable is the AI-Code Risk (beta) engine?
+
It's intentionally conservative. Findings are capped at Medium severity, phrased as advisory rather than confirmed, and the engine explicitly states that an unauthenticated scan can't prove a flaw exists — only that a pattern is worth a human second look.
What are AEO and GEO, and why do they matter alongside SEO?
+
SEO gets your app found by traditional search engines. AEO (Answer Engine Optimization) and GEO (Generative Engine Optimization) are the same idea applied to AI systems — ChatGPT, Perplexity, Google AI Overviews — that answer questions directly instead of listing links. They check the structured data and trust signals those systems use to decide whether to cite or recommend a product at all.
Do all 33 engines run on every scan?
+
All 27 always-run engines run on every scan, including the free tier. Whether you get all 33 depends on domain verification: the 6 verified-only engines only run once ownership is confirmed. Visibility (SEO/AEO/GEO) results are always shown in full and are never paywalled.
More guides: Supabase RLS: the #1 vibe-coding bug · Exposed API keys in AI-built apps · Full vibe-coding security checklist · IDOR: the sequential-ID bug · Webhook signature verification