hunt-spa-api
Discover a single-page-app's hidden backend API from its public JS bundle, then test that API for broken access control / missing authentication.
Install / Use
npx skills add elementalsouls/Claude-BugHunter --skill hunt-spa-apiInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Our assessment of hunt-spa-api
hunt-spa-api scores 94/100 on our quality scale, 442nd of 4,700 Development & Engineering skills we index (top 10%).
Its SKILL.md is 8.7 KB long, well organised into 21 sections with 6 code examples: a thorough specification that gives an agent plenty to work with.
With 5,198 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated 26 days ago, so hunt-spa-api is actively maintained.
- Our last check on 2026-11-16 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-09-29. Automated pattern scan on 2026-09-28. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
hunt-spa-api compared with similar skills
All 4 of these similar skills score higher than hunt-spa-api; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| hunt-spa-api (this skill)by elementalsouls | 94 | 5.2k | 26d ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 9d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.8k | today | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
Frequently asked questions
- How do I install hunt-spa-api?
- Run
npx skills add elementalsouls/Claude-BugHunter --skill hunt-spa-api. The install tabs above show the steps for each supported agent. - Which AI agents does hunt-spa-api work with?
- It is written for Zed, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is hunt-spa-api safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is hunt-spa-api still maintained?
- The repository was last updated 26 days ago, so hunt-spa-api is actively maintained.
Skill content
View source on GitHubname: hunt-spa-api
description: Discover a single-page-app's hidden backend API from its public JS bundle, then test that API for broken access control / missing authentication. One of the highest-yield web plays in modern recon — SPAs ship their entire backend route map to the browser, and the API behind them is frequently missing the auth middleware the login page implies. Built from an authorized engagement where this play found an unauthenticated financial API that an ASM scan reporting hundreds of "Criticals" completely missed. Use whenever a target serves a JS-heavy SPA (React/Vue/Angular/Next), an "app"/"console"/"dashboard"/"portal" subdomain, or any *api* host shows up in recon. Leaked build artifacts (source maps / .env / .git / asset-manifest) are owned by hunt-source-leak; API version-inventory and behavioral diffing by hunt-shadow-api; this skill owns mapping a live SPA's backend routes from its JS bundle and testing them for broken access control / missing auth.
sources: authorized-engagement
report_count: 1
When to use this skill
Trigger when:
- A target host returns a tiny HTML shell + big
/static/js/*.jsor/_next/static/*bundles (React/Vue/Angular/Next/Svelte SPA) - You see a subdomain named
console,app,dashboard,portal,admin,panel,manage,internal - Recon surfaces any
*api*,*-api*,api.*host - A login page is OAuth/SSO-gated (the frontend auth tells you nothing about whether the API enforces auth)
The core insight: a SPA is a client to a backend API, and it ships the full map of that API — hosts, routes, sometimes keys — to anyone who views source. The login page being protected says nothing about whether the API behind it checks tokens. Auth is frequently enforced on the gateway/login and missing on a route group of the API.
DO NOT skip this because "the app needs login" — that's exactly when this pays off.
The play (5 steps)
1. Pull the shell + enumerate the bundles
curl -s https://console.target.com/ -o index.html
# React/CRA:
grep -oE '/static/js/[^"]+\.js' index.html
# Next.js:
grep -oE '/_next/static/[^"]+\.js' index.html
# generic:
grep -oiE 'src="[^"]+\.js[^"]*"' index.html
Download every bundle (they can be multi-MB — that's fine, it's all route data):
mkdir bundles
for j in $(grep -oE '/static/js/[^"]+\.js' index.html | sort -u); do
curl -s "https://console.target.com$j" -o "bundles/$(echo "$j"|tr '/' '_')"
done
2. Harvest API hosts, routes, and secrets from the bundles
B=bundles/*.js
# Backend API hosts (incl. dev/beta/staging variants — often weaker auth)
grep -ohiE 'https://[a-z0-9.-]*(api|console|backend|service)[a-z0-9.-]*\.target\.com[a-z0-9/_-]*' $B | sort -u
# Versioned API base paths
grep -ohiE '/api/v[0-9]+/?' $B | sort -u
# Route literals — minified bundles store routes as STRING segments, not full URLs.
# Grep for quoted "resource/action" strings:
grep -ohiE '"[a-z0-9_-]+/[a-z0-9_/-]+"' $B | tr -d '"' \
| grep -iE '(login|user|account|order|billing|invoice|payment|deal|report|token|otp|password|reset|admin|profile|auth|upload|export|role|permission|dashboard|wallet|finance|sales)' | sort -u
# Secrets (validate before trusting — most AIza keys are Maps/analytics, not Auth)
grep -ohiE '(AIza[0-9A-Za-z_-]{35}|AKIA[0-9A-Z]{16}|sk_live_[0-9A-Za-z]+|eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}|apiKey["'"'"']?\s*[:=]\s*["'"'"'][^"'"'"']+)' $B | sort -u
Note: minifiers store routes as concatenated string segments (e.g. "account/payment/list"), NOT full /api/v2/... URLs — so a naive /api/v* grep returns nothing. Grep for the resource-word route strings and prepend the base yourself.
Lazy-loaded (async) chunks — don't stop at HTML-referenced bundles. CRA/webpack SPAs reference only runtime+main+vendor in index.html; numbered async route chunks are named inside main.js's chunk map and loaded at runtime, so grepping only /static/js/*.js from the shell truncates route coverage to eager chunks.
grep -oE '[0-9]+:"[a-f0-9]+"' bundles/*main*.js # {chunkId:"hash"} pairs
# reconstruct /static/js/<id>.<hash>.chunk.js, download each, re-run route/host/secret harvest
# asset-manifest.json (if present) lists them all -> hunt-source-leak
3. Establish a CONTROL — find an endpoint that IS gated
Before declaring anything vulnerable, send an unauthenticated request to an endpoint you expect to be protected, and capture what correct rejection looks like:
curl -s -X POST https://api.target.com/api/users -H 'Content-Type: application/json' -d '{}'
# secure → {"error":"Missing or invalid authorization header"} or HTTP 401
This is your differential. A sibling API (e.g. a second API host, or a different route group on the same host) is the ideal control — same stack, so a different response = real authz gap, not a quirk.
4. Test each route family UNAUTHENTICATED, both methods
For every discovered route, send it with no Authorization header and compare to the control:
for r in <routes>; do
curl -s -o /tmp/r -w "[%{http_code}] $r\n" -X POST -H 'Content-Type: application/json' -d '{}' "https://api.target.com/api/v2/$r"
done
Interpret:
401/"Missing authorization"→ gated (correct). Move on.200with data → unauthenticated data exposure. Finding.400 "field X is mandatory"→ the route processed your request and reached business-logic validation without an auth check → auth bypass; supply the field minimally to confirm.200+ verbose DB/stack error (e.g.PROCEDURE db_x.sp_y does not exist) → reached the data layer unauthenticated; also a SQLi-surface signal.- Mandatory fields named like
is_admin/is_internal/requested_by/role_id/account_type→ authorization derived from client-supplied parameters — set the privilege flag and you self-elevate. Critical-class.
5. Pivot & prove (minimally)
- IDs returned by one endpoint (
account_id,order_id,deal_id) are the keys the other endpoints consume — they prove the whole router is reachable, not just one route. - Test
dev-/beta-/staging-API variants — they frequently have weaker/disabled auth. - Check the response headers:
Access-Control-Allow-Origin: *compounds the issue (any web origin reads it from a victim's browser). - STOP at minimum-necessary proof. A handful of records (or a
totalCount) confirms the missing check. Do NOT enumerate the table — seeredteam-mindsetdata-minimization boundary. The finding is the absent auth, not the data volume.
What "the API behind the SSO login" really means
A common, dangerous architecture:
console.target.com(the SPA) → login is Entra/Okta/Google OAuth (looks airtight).api.target.com(the backend) → some route groups enforce the bearer token, some route groups forgot the middleware.
The frontend login is theatre if the API doesn't independently validate the token on every route. Always test the API directly, bare, regardless of how locked-down the login UI is.
Anti-patterns
- "The app requires login, so the API must be protected." No — test the API directly, unauthenticated. The whole point.
- "Minified bundle, can't read it." You don't need to read it — grep it for hosts/routes/secrets. 5 minutes.
- "
/api/v1/fooreturned 404, so no API here." Wrong base or wrong method. Try/api/,/api/v2/, POST not GET, and the exact route strings from the bundle (Express's 404 echoes the path — use it to calibrate). - "AIza key found → critical secret." Validate first — most are Maps/analytics keys (
CONFIGURATION_NOT_FOUNDon identitytoolkit = not Auth-enabled). Don't over-claim. - Dumping the whole dataset once you get a 200. Stop at PoC. (
redteam-mindset.) - Account-creation / write endpoints as "proof". Read endpoints prove the auth gap without creating state. Never POST a
create/signup/uploadto "demonstrate" — that's a destructive write needing explicit per-action authorization.
Related Skills & Chains
hunt-api-misconfig— once the API is mapped, run the broader misconfig matrix (method tampering, mass assignment, JWT alg confusion) per route.hunt-idor— theaccount_id/order_idpivots feed straight into IDOR testing across discovered routes.hunt-source-leak— sourcemaps (*.js.map) reconstruct original source for deeper route/secret extraction; same harvesting muscle.hunt-nextjs— for Next.js targets, layer the middleware-bypass (x-middleware-subrequest) and/_next/dataroute tests on top of this.redteam-mindset— the data-minimization boundary governs step 5: prove the missing check, don't exfiltrate the table.recon-scope-triage— verify the API host actually belongs to the target before testing (don't pop a same-named third party's API).
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
headroom
79.8kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
