What we scan for

An Anthropic API key (sk-ant-…) was found in client-visible code.

An AWS access key id (AKIA…/ASIA…) was found alongside its 40-character secret access key in client-visible code — a complete, immediately-usable credential.

An Azure Storage AccountKey= shared key was found in client-visible code.

A database URL containing an inline user:password (Postgres/MySQL/MongoDB/Redis/AMQP) was found in client-visible code.

A DigitalOcean personal access token (dop_v1_/doo_v1_/dor_v1_) was found in client-visible code.

A Docker Hub access token (dckr_pat_…) was found in client-visible code.

A Doppler token (dp.pt.… / dp.st.… …) was found in client-visible code.

A high-entropy value assigned to a secret-named variable (e.g. SESSION_SECRET, JWT_SIGNING_KEY, api_secret, db_password, client_secret) was found in client-visible code — a credential regardless of provider prefix.

A GitHub fine-grained personal access token (github_pat_…) was found in client-visible code.

A GitHub token (ghp_/gho_/ghu_/ghs_/ghr_) was found in client-visible code.

A GitLab personal access token (glpat-…) was found in client-visible code.

A Google OAuth client secret (GOCSPX-…) was found in client-visible code.

A Groq API key (gsk_…) was found in client-visible code.

A Hugging Face access token (hf_…) was found in client-visible code.

A Linear API key (lin_api_…) was found in client-visible code.

A Mailchimp API key (<hex>-usN, corroborated by a nearby 'mailchimp' token) was found in client-visible code.

A Mapbox secret token (sk.…) was found in client-visible code.

A Netlify personal access token (nfp_…) was found in client-visible code.

A New Relic API key (NRAK-…) was found in client-visible code.

An OpenAI API key (sk-…, incl. sk-proj-/sk-svcacct-) was found in client-visible code.

A Perplexity API key (pplx-…) was found in client-visible code.

A PlanetScale password or service token (pscale_pw_… / pscale_tkn_…) was found in client-visible code.

A PEM-encoded private key block (RSA/EC/DSA/OpenSSH/encrypted PKCS#8/PGP) was found in client-visible code.

A PyPI upload token (pypi-AgEIcHlwaS…) was found in client-visible code.

A SendGrid API key (SG.…) was found in client-visible code.

A Shopify access token (shpat_/shpca_/shppa_/shpss_) was found in client-visible code.

A Slack token (xoxb-/xoxp-/xoxa-/xoxr-/xoxs-/xoxe-/xapp-) was found in client-visible code.

A Square access token (sq0atp-/sq0csp-) was found in client-visible code.

A Stripe sk_live_ secret key was found in client-visible code.

A Supabase sb_secret_ secret key was found in client-visible code.

A Supabase service_role JWT was found in client-visible code — this key bypasses Row-Level Security.

An AWS access key id (AKIA…/ASIA…) was found in client-visible code, with no secret access key alongside it.

A Figma personal access token (figd_…) was found in client-visible code.

A Mailgun API key (key-…, corroborated by a nearby 'mailgun' token) was found in client-visible code.

An npm access token (npm_…) was found in client-visible code.

A Postman API key (PMAK-…) was found in client-visible code.

A Slack incoming-webhook URL (hooks.slack.com/services/…) was found in client-visible code.

A Stripe rk_live_ restricted key was found in client-visible code.

A Stripe sk_test_ test-mode secret key was found in client-visible code.

A Stripe whsec_ webhook signing secret was found in client-visible code.

A Telegram bot token (<id>:AA…) was found in client-visible code.

A Twilio API key (SK…, corroborated by a nearby 'twilio' token) was found in client-visible code.

A Google/Firebase browser API key (AIza…) was found in client-visible code. These are usually public by design and meant to be referrer/app-restricted.

A schema-built query executed anonymously returned records containing sensitive-looking fields — the GraphQL analog of broken access control.

A logged-in test user could not list a table's rows, yet could fetch another user's specific object directly by its id — object-level authorization is missing (the classic BOLA / IDOR shape, on a table that often exposes no owner column).

A logged-in test user that owns no rows in a table could still read another user's rows, and those rows carry sensitive data — access control is not scoped per user.

A PocketBase/Appwrite collection returned records with sensitive-looking fields to an anonymous list request.

An anonymous GET /_all_dbs succeeded — the CouchDB server has no admin configured ('admin party'), so every database is world-accessible.

An anonymous read of a CouchDB database returned documents with sensitive-looking fields.

An anonymous GET /_cat/indices succeeded — the cluster is unauthenticated, so all indices are world-accessible.

An anonymous _search of an index returned documents with sensitive-looking fields.

An anonymous (or public-API-key) GraphQL query returned records containing sensitive-looking fields.

An anonymous SELECT returned rows containing sensitive columns or sensitive values (PII, credentials, financial data).

An anonymous INSERT was accepted by the table's row-level-security policies.

An anonymous read of a Firestore collection returned document data — the collection's `allow read` rule lets unauthenticated clients through.

An anonymous read of the Realtime Database root succeeded — the database's .read rule allows unauthenticated access.

An anonymous list of the default Firebase Storage bucket returned object metadata — the Storage rules allow unauthenticated read/list.

An S3/GCS/Azure bucket allows anonymous listing, and the sampled object names match private-data patterns (backups, invoices, KYC, .env, …).

A Supabase Storage bucket returns objects to an anonymous list request, and the sampled names match private-data patterns.

An anonymous GET of an API route returned sensitive-looking (PII-shaped) fields — the endpoint appears to serve private data without authentication.

A table with no per-user ownership column returned a row readable by more than one user, so it has no per-user access scoping — and the rows carry sensitive data. Indistinguishable by structure alone from an intended public/shared table.

A logged-in test user that owns no rows in a table could read another user's rows, but no sensitive columns were detected — possibly a public feed by design.

A logged-in test user owns rows in a table AND can read rows owned by others — structurally identical to a legitimate shared/co-membership/public-profile table, so it cannot be confirmed a leak by data alone.

A value-neutral update by a logged-in test user succeeded against another user's row — the write (UPDATE) policy is not scoped per owner.

An anonymous INSERT was accepted on a table that looks like an intake/submission form (contact, waitlist, feedback, signup).

An S3/GCS/Azure bucket allows anonymous listing; the objects are not recognizable public assets, so exposure is possible but unconfirmed.

An anonymous GET /storage/v1/bucket returns the project's bucket names — the storage bucket metadata is world-readable.

A Supabase Storage bucket is anonymously listable; the objects are not recognizable public assets, so exposure is possible but unconfirmed.

The backend's GraphQL endpoint answers an introspection query, exposing the full schema (types, fields, operations).

A PocketBase/Appwrite collection returned records to an anonymous request, but no sensitive field patterns were seen — likely public-by-design.

An anonymous read of a CouchDB database returned documents, but no sensitive field patterns — likely public-by-design.

An anonymous _search of an index returned documents, but no sensitive field patterns — likely a public search index.

An anonymous SELECT returned rows, but no sensitive column or value patterns were detected — likely intentionally public.

The app's code calls Supabase RPC functions. A function defined SECURITY DEFINER runs with the definer's privileges and bypasses row-level security — an anon-callable one would be an RLS-bypass vector. This is presence-only: we detect the calls in the bundle but do NOT invoke the functions, so anon-callability and SECURITY DEFINER are unconfirmed.

An S3/GCS/Azure bucket allows anonymous listing and its objects look like public CDN assets (images, css, js).

A public r2.dev URL is referenced — an R2 bucket exposed through Cloudflare's public-by-design dev endpoint.

A Supabase Storage bucket is anonymously listable and its objects look like public assets.

The Spring Boot actuator /env endpoint is public and dumps the app's property sources.

The Spring Boot actuator /heapdump endpoint is public, serving a full JVM heap dump.

An ~/.aws/credentials INI file exposing aws_access_key_id / aws_secret_access_key is downloadable.

A ZIP archive (backup.zip / www.zip / public_html.zip) — confirmed by its archive magic bytes — is downloadable.

A plaintext credentials file (~/.netrc or ~/.pgpass) is downloadable and returns real credential lines, not HTML.

A Docker CLI config (~/.docker/config.json) with an `auths` block is served publicly.

A .env-style environment file (any variant — .env, .env.production, .env.bak, …) is downloadable and returns real KEY=value lines, not an HTML page.

A kubeconfig (~/.kube/config) with cluster credentials is served publicly.

A PEM private key (e.g. .ssh/id_rsa, id_rsa) is downloadable.

A Rails config/database.yml (or /database.yml) is served publicly and contains a literal database password.

A GCP/Firebase service-account or OAuth credential file (serviceAccount.json, firebase-adminsdk.json, credentials.json) with a private_key is downloadable.

A VS Code SFTP deploy config (.vscode/sftp.json) exposing a host plus a password or private-key path is downloadable.

A SQL dump (backup.sql / dump.sql / database.sql) with CREATE TABLE / INSERT statements is downloadable.

A Terraform state file (terraform.tfstate) is downloadable.

A wp-config.php backup (wp-config.php.bak/~/.save/.old) is served as raw source, exposing DB_PASSWORD and auth salts.

The Spring Boot actuator index is public, listing management endpoints (env, beans, mappings, …).

A docker-compose.yml/.yaml is served publicly, exposing service environment variables and topology.

A .NET appsettings.json carrying ConnectionStrings or other secrets is served publicly.

Git internals (.git/config, .git/HEAD, or .git/logs/HEAD) are served publicly.

The Laravel application log (storage/logs/laravel.log) is served publicly.

An .npmrc (or similar registry config) containing a _authToken / _auth / _password is downloadable.

A phpinfo() page is publicly reachable (e.g. /phpinfo.php).

A JSON config file (e.g. config.json) served publicly contains sensitive-looking keys (api_key, secret, password, token).

The Apache mod_status page (/server-status) is publicly reachable.

The WordPress /wp-content/debug.log is served publicly, exposing PHP errors and stack traces.

A macOS .DS_Store file is served publicly; it discloses the names of other files in the directory.

The WordPress /wp-json/wp/v2/users endpoint returns the site's usernames.

The WordPress /xmlrpc.php endpoint is enabled and responding.

The certificate the site serves for HTTPS is past its expiry date.

The served certificate's start (not-before) date is in the future, so it isn't valid yet.

The served certificate is valid now but expires within the next 30 days.

The served certificate's subject/SAN names do not cover the hostname being visited.

The certificate is self-issued (issuer equals subject), so it does not chain to a publicly trusted certificate authority.

The served certificate's RSA public key is smaller than the 2048-bit minimum.

The served leaf certificate is signed with a collision-broken hash (SHA-1, MD5, or MD2).

The domain publishes no DMARC (_dmarc, v=DMARC1) policy, so mailbox providers have no instruction to quarantine or reject failing mail.

This subdomain has no DMARC record of its own, and the organizational domain's policy does not enforce on subdomains (sp=none, or no sp= tag with p=none) — so mail spoofing this subdomain is not rejected.

The DMARC record uses p=none (monitor-only) or omits the required p= tag, so failing mail is still delivered.

The domain publishes no SPF (v=spf1) TXT record, so receivers have no authorized-sender policy to check.

The domain publishes more than one v=spf1 record; per RFC 7208 this is a permerror and SPF may be ignored entirely.

The SPF record ends in "?all" (neutral): it expresses no pass/fail policy.

The SPF record ends in "+all", which explicitly authorizes every host on the internet to send as this domain.

The server returns Access-Control-Allow-Origin: null together with Access-Control-Allow-Credentials: true.

The server echoes any request Origin back in Access-Control-Allow-Origin together with Access-Control-Allow-Credentials: true.

Access-Control-Allow-Origin: * is sent together with Access-Control-Allow-Credentials: true.

The server returns Access-Control-Allow-Origin: null, but without credentials.

The server echoes any request Origin back in Access-Control-Allow-Origin, but without credentials.

Access-Control-Allow-Origin: * without credentials — common and low-risk for public data.

The detected WordPress core version is on a branch several releases behind the current line, so it is missing the accumulated security fixes WordPress backports to maintained branches.

A WordPress plugin was detected at a version below the patch for a known CVE (the version is inferred from the plugin's asset URL).

A client-side JavaScript library is loaded at a version below the fix for one or more known CVEs (the version is observed in a script URL or the library's own version banner).

A WordPress plugin with a known CVE history was detected, but its version could not be read from the page assets — so vulnerability can't be confirmed or ruled out.

A cross-origin (third-party) subresource — a <script>, stylesheet, or module/preload — is loaded without a Subresource Integrity (SRI) hash, so the browser can't verify the file wasn't tampered with before running or applying it.

A cross-origin subresource carries an `integrity` hash but no `crossorigin` attribute. On a cross-origin resource the browser fetches in no-cors mode and gets an opaque response it cannot read, so the SRI hash is silently NOT enforced — the pin does not take effect.

The API's GraphQL endpoint answers an introspection query, exposing the full schema (queries, mutations, types).

An OpenAPI/Swagger specification is served publicly, documenting every route and parameter of the API.

A JavaScript bundle references a publicly-served .map file whose sourcesContent reconstructs the original, un-minified source (comments, internal logic, endpoints).

The Server response header includes a version number.

The X-Powered-By response header advertises the server framework (and sometimes its version).

An AWS Cognito identity pool allows unauthenticated access, so an anonymous request obtains temporary AWS credentials with no sign-in.

The Firebase project's authorizedDomains list contains a wildcard entry, widening the OAuth redirect surface.

The Clerk environment config (readable from the public Frontend API with the publishable key) shows sign-up mode is "public" — anyone can self-register.

The Firebase project config (readable with the public web API key) shows email/password sign-up is open to anyone.

The server negotiated a genuinely broken cipher (RC4, EXPORT, or NULL) from a weak-only ClientHello.

Even when offered strong suites, the server chose a weak (non-AEAD) cipher.

The server accepts the legacy 3DES (Triple-DES) cipher suite.

The server negotiated a static-RSA key-exchange cipher even though modern ECDHE suites were offered, so sessions have no forward secrecy.

A session-looking cookie is readable by JavaScript because it lacks the HttpOnly attribute.

A session-looking cookie is set without the Secure attribute on an HTTPS site.

A session-looking cookie has no SameSite attribute.

AI-agent / Model Context Protocol wiring is reachable from the client (an mcpServers block, MCP SDK, or an MCP server reference).

A client-visible AI/LLM integration was detected — an LLM provider host called from the browser and/or an agent framework in the bundle.

A CSP exists but its script policy allows unsafe-inline, unsafe-eval, or a wildcard source.

One or more defense-in-depth response headers (HSTS, CSP, X-Content-Type-Options, frame protection, Referrer-Policy) are missing.

A DNS record (via CNAME) points at a hosting service resource (S3 bucket, GitHub Pages site, Heroku app, …) that is unclaimed — the service returned its distinctive 'unregistered' response.

The site served a framework debug or stack-trace page instead of a generic error — leaking its framework and version, server file paths, and often source snippets, SQL, or configuration.

The server still completes handshakes over TLS 1.0 and/or 1.1, which are formally deprecated.

Strict-Transport-Security is set but with a max-age under a day (or 0).