Spider King skill
A skill for taking apart web clients with signatures, tokens and bot protection: the result is a browser-free Python collector
- 523 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- The skill takes apart site protections and runs third-party JS and WASM in a local environment, and such code can be malicious
- Using it against sites you have no permission for breaks service terms and the law
- The work handles cookies, tokens and personal data
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/spider-kingDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- The skill takes apart site protections and runs third-party JS and WASM in a local environment, and such code can be malicious
- Using it against sites you have no permission for breaks service terms and the law
- The work handles cookies, tokens and personal data
This is third-party code. Review the repository files before installing.
What it does
Spider King recovers a web protocol. It takes a site where a request is signed by a script, a token rotates or the response arrives encrypted, and breaks the chain down into a repeatable Python solution with no browser. The work is evidence-first: find the real request and the source of dynamic state, rebuild it locally, and only then deal with paging and scale. Before starting, the skill picks a mode itself: `artifact-only` when samples exist, `live-target` for a live site or `continuation`, and decides whether a browser is needed. For a live target the order is strict: a fingerprint baseline through Chrome DevTools, then a debugger trace through js-reverse. The `references/` playbooks cover signatures, response decoding, WebSocket, GraphQL, protobuf, WASM, dynamic fonts, cookie chains and calls that break on replay. Three ready profiles exist: browser hooks, AST restoration and environment patching. The output comes in four shapes, from proof to collector: `evidence`, `local-proof`, `compact-replay` and `collector`. By the author's description the repository holds 14 scripts, 12 test files and a pure-replay example for Douyin.
Who it is for. Data engineers and security researchers who need to take apart a web client's signatures and tokens with authorization and end up with a repeatable collector.
Good fit when
- A request is signed by a script in the browser and the signature must be rebuilt in Python
- You have a HAR or packet capture and need to explain where dynamic fields come from without opening a browser
- A response arrives encrypted, as protobuf or with a dynamic font and needs a decoder
- Replaying a request gives 403 or 412 while the browser passes, and you need the first point of divergence
- The built solution must pass several runs reliably and page through results
Not a fit when
- The target is an APK, native app or mini-program: the skill declares them out of its main scope
- You need browser automation with clicks: the skill's output is a browser-free solution
- You have no authorization for the target: the skill takes apart a site's defenses and fits only your own sites and permitted research
- The plan is to extract personal data or bypass a service's limits against its terms: that breaks the terms and the law
Example request
Using the attached HAR, work out how the signature parameter in the list request is built and recreate it in Python without a browserLimitations
The documentation and most playbooks are in Chinese and `SKILL.md` is in English. For a live target the skill relies on mounted `chrome-devtools` and `js-reverse` MCP servers; without them work happens offline on ready samples. The final solution needs Python and an installed curl-impersonate, and the skill claims current live acceptance only after several successful runs. Examples are tied to specific services and their protection versions and age with them.
How to disable. Delete the spider-king folder from the agent's skills directory, for example `.claude/skills/` or `~/.claude/skills/`. The skill writes working files to `js_reverse_cache/tasks/<id>/` in the project, so delete that folder separately.
FAQ
How do I install Spider King in Claude Code?
Clone the repository into your skills folder, for example `git clone https://github.com/aoyunyang/spider-king-skill.git ~/.claude/skills/spider-king`. `SKILL.md` with `name: spider-king` sits in the root.
Is a browser needed?
For a live target yes: a baseline through Chrome DevTools, then js-reverse. The final collector does not depend on a browser. `artifact-only` mode with ready HAR files and captures needs none.
What is Auto Judge?
The first-move rule. From the task's signals the skill picks a mode (`artifact-only`, `live-target` or `continuation`) and only then turns tools on.
Does it suit mobile apps?
No. APKs, native apps and mini-programs are declared out of scope and the skill says so outright.
Is it legal to use?
It depends on the target. Your own sites, authorized tests and public data within a platform's rules are fine. Taking apart another service's protections against its terms can breach a contract and the law.
Discussion
No questions or reviews yet.
Related
SkillsVibeSec
VibeSec-Skill
A secure coding skill: the agent looks at code from a bug hunter's perspective and prevents common web vulnerabilities
A security scanner for agent skills: finds prompt injection, data exfiltration and malicious code before you install
122 skills for reverse engineering: malware, firmware, protocols, mobile apps, CTF work and vulnerability research.
The SecKnowledge skill loads a web-vulnerability and AI-app risk knowledge base into an agent for security testing of a target.
A skills router for authorized reverse engineering, pentest, CTF and threat analysis: it picks a methodology for the task and checks available tools
Security scanner for agent skills and MCP servers: finds prompt injection, data exfiltration and supply chain risks before install
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Repository stars | Main difference |
|---|---|---|---|
| Spider King (this card) | no | 523 | |
| reverse-skill | no | 44,204 | a skill router for authorized reverse engineering, pentesting and CTF across many targets |
| Reverse API Engineer | no | 2,718 | records a site's traffic to HAR and writes an API client from it |
README in short
The Chinese description opens with the goal: bring protected web clients back to a reproducible protocol. It then covers what versions 8.0, 7.0 and 6.0 added, a feature list, a five-step method and the repository tree.
README badge
Original SKILL.md
--- name: spider-king description: "Pure-web protocol reverse skill: turn hostile browser clients into browser-free Python collectors. Auto-judge intake and tool path: artifact-only when samples suffice; fresh web live-target needs sequential fingerprint-baseline then debugger-trace (default chrome-devtools then js-reverse; if DP is already required js-reverse may own both roles on one host and must not launch a second Chrome; replay identity locks to installed curl impersonate; unknown risk-control does not bulk-add unproven extra routes; Camoufox/managed baseline only on fingerprint pressure; silent-value-capture is a first-class debugger-trace means when attach is missing or page-world capture is insufficient/observer-toxic). Continuation reuses the current gate. Route only mounted web MCP families. Out of scope as primary path: APK, native app, mini-program. Use for hostile web sign, token, cookie, WebSocket, GraphQL, protobuf, response-decode, fingerprint, WASM, challenge-bootstrap, dynamic-font, or protocol-collector flows." --- # Spider King ## Mission Turn hostile web clients into stable protocol collectors. This is a pure-web protocol-recovery skill, not a browser-automation skill and not an APK/mini-program reverse skill. Use browser tooling only to gather web evidence. Deliver raw HTTP plus narrow local sign, bootstrap, decode, or transport helpers. If the primary target is APK, native app, or mini-program, state out-of-scope instead of inventing a web dual-browser first-pass. ## Non-Negotiables - Before any tool choice on a fresh task, run the Auto Judge Card in this file and `references/mcp-routing-playbook.md`: decide intake, whether a browser is needed, which baseline host to use, and which debugger-trace means to use (`js-reverse` and/or `silent-value-capture`). Do not open tools first and rationalize later. - Start every fresh web target classified as `live-target` with sequential evidence for both roles before claiming that the page/runtime is understood: `fingerprint-baseline` then `debugger-trace`. The only narrower claim is the `transport-only direct-endpoint exception` in `references/startup-triage-playbook.md`: it may accept a collector for one exact endpoint without claiming page/runtime understanding, and only after its strict negative-control and business-oracle gates pass. - Default means are baseline `chrome-devtools` then debugger-trace `js-reverse`. If DP/initiator work is already required, `js-reverse` may own both roles on one host; do not launch a second Chrome. Record `launch` vs `attach` and never pretend launch is attach. Upgrade the baseline host to Camoufox or another managed profile only on proved fingerprint pressure or clean-baseline failure; never default Camoufox for ordinary low-risk work or because CDP `navigator.webdriver` is true. - Satisfy `debugger-trace` with correlated initiator/mutation proof from `js-reverse`, correlated `silent-value-capture` cards under `references/silent-value-capture-playbook.md`, or both. Prefer `js-reverse` when attach exists. - If attach is missing, record `debugger_attach_gap` and continue debugger-trace via `silent-value-capture` when a backend is available instead of abandoning the role. If a needed silent backend is also missing, record `silent_value_capture_gap` and continue offline or lower the delivery shape. - Silent-value-capture never replaces baseline and never owns `compact-replay` or `collector` delivery. APK, native app, and mini-program primary tasks remain out of scope and must not invent paired-browser proof as ceremony. If a required role cannot be satisfied by any available means, report the blocker before claiming the live target is understood. - Keep browser and engine-capture evidence collection target-serial: at most one browser or engine-capture family may be `TARGET_ACTIVE`, and never place two target owners in the same parallel tool batch. Apply the handoff gate in `references/tool-playbook.md`; park or retain baseline before granting silent-value engine capture; preserve unique unreplayable state with `RETAINED_EXCEPTION` instead of destroying it for cleanup. - For `compact-replay` and `collector`, deliver a browser-free Python run path. Never use browser automation, Playwright, Selenium, CDP page-driving, page-context fetch, browser profiles, manual browser state, silent-value-capture backends, or engine instrumentation as the final replay path or fallback. - Prefer pure Python for HTTP, orchestration, parsing, retries, persistence, and output. Keep JS/WASM only as a tiny local helper when a verified Python port would be riskier; a local bootstrap may emulate host semantics, but Python owns live HTTP and the report states browser-free/runtime-free truth. Replay identity locks to the installed curl impersonate chrome major; do not copy a newer live Chrome major onto a lower impersonate or restart risk-control reverse for that drift. - Recover one stable business request before pagination, concurrency, submission, or runtime shrinking. Unknown risk-control reverses the rejected request first; unproven extra routes are at most one per round and only after omission changes the oracle. - When a local JS/WASM/SDK helper is called repeatedly in one browser-shaped workflow, treat process/VM/context identity and hidden mutable state as moving parts; prove persistent-world versus fresh-world behavior before shrinking or widening the helper, and do not reuse a self-invalidating instance as a pager. - Back every conclusion with the evidence its declared shape requires. Require repeated live replay only when claiming current live acceptance. Keep raw sensitive values local; redact credentials, tokens, personal data, and cookie values from chat, reports, and version control. - Never hardcode rotating state before proving its writer, slot, scope, expiry, and refresh path; preserve one session chain for bootstrap-heavy flows until cross-session reuse is proven. - Stop only when the declared shape passes its capability-specific gate or a real external blocker is proved. Do not label `evidence` or `local-proof` as a collector, and do not disguise incomplete automation as a temporary collector. - `compact-replay` and `collector` delivery include a PyCharm right-click runnable Python entrypoint, normally project-root `main.py` or `collector/main.py`, with no required terminal arguments. `evidence` and `local-proof` do not require an entrypoint unless the requested artifact is executable code. - Route only MCP families confirmed in the current tool registry/schema; disk source trees are not availability. Passive wire stores may coexist with `TARGET_ACTIVE` but do not replace live first-pass evidence, and `compact-replay`/`collector` remain free of browser runtime, page driving, profiles, capture backends, and engine instrumentation. - Before hardening a gate-family label, widening runtime, or handing work to an installed specialist, pass `references/evidence-corroboration-gate.md`. One status code, cookie name, token name, old note, or plausible helper output is only a hypothesis. - When a trusted positive sample passes and the local path fails, use `references/positive-sample-ablation-playbook.md` after sample hygiene. Name unfinished live failures with `references/failure-surface-taxonomy.md` instead of implying collector completion. When stuck, pick one Stuck next action from that file; do not bulk-add unproven extra routes. For failure-shaped counterexamples, read `references/anti-patterns-playbook.md`. Before packaging a result, apply only the matching capability gate from `references/delivery-gate-playbook.md`. Graded degrade: import/`NameError` is our bug (alarm on stderr); external timeout is fallback. Print key responses to stderr; keep stdout machine JSON. ## Lightweight Dispatch Use these labels internally to keep the first move small. Do not force a rigid machine header in normal user replies.