Parameters: A Complete Guide to Hidden Parameter Discovery Tools
Parameters: A Complete Guide to Hidden Parameter Discovery Tools
Hidden parameters are a goldmine for bug bounty hunters and penetration testers. They can unlock functionality, bypass access controls, trigger debug modes, or expose sensitive data. Many web applications accept parameters that are not linked anywhere in the visible interface—undocumented API parameters, legacy debug flags, or forgotten admin switches. Discovering them manually is impractical, but the tools in this guide automate the process.
This guide covers six powerful parameter discovery tools: parameth, param-miner, ParamPamPam, Arjun, ParamSpider, and x8. Each takes a different approach—brute-forcing, mining archives, or intercepting traffic—and together they form a comprehensive toolkit for expanding your attack surface.
⚠️ Legal and ethical notice: Parameter discovery sends requests to target servers and may trigger unexpected behavior. Only use these tools against systems you own or have explicit written authorization to test. Unauthorized scanning and fuzzing may violate laws and terms of service.
Table of Contents
- Why Parameter Discovery Matters
- Tool Overview
- parameth
- param-miner
- ParamPamPam
- Arjun
- ParamSpider
- x8
- Comparison Table
- Best Practices & Workflow
- Final Tips
1. Why Parameter Discovery Matters
Every parameter is a potential entry point. A hidden debug=1 might expose stack traces. A forgotten admin=true could grant elevated privileges. An undocumented file= parameter might be vulnerable to local file inclusion. Even a parameter that returns the same response as no parameter can be valuable if it changes server-side behavior in subtle ways—like web cache poisoning.
Parameter discovery helps you:
- Find hidden functionality – Debug modes, admin switches, legacy features.
- Expand the attack surface – More parameters mean more things to test.
- Bypass access controls – Sometimes a parameter changes authorization checks.
- Discover APIs – Undocumented parameters often exist on API endpoints.
- Identify web cache poisoning vectors – Unkeyed parameters can poison caches.
The tools below automate the tedious work of guessing parameter names and analyzing responses.
2. Tool Overview
| Tool | Language | Approach | Best For |
|---|---|---|---|
| parameth | Python | Brute-force GET/POST params | Quick, simple discovery |
| param-miner | Java (Burp) | Passive/active Burp extension | Burp Suite users, web cache poisoning |
| ParamPamPam | Python | Brute-force GET/POST params | Fast, focused brute-forcing |
| Arjun | Python | HTTP parameter discovery suite | Thorough, multi-method discovery |
| ParamSpider | Python | Mining web archives | Passive, historical parameter discovery |
| x8 | Rust | Hidden parameters discovery | High-speed brute-forcing |
3. parameth
parameth is a Python tool that brute-discovers GET and POST parameters. It compares responses to identify parameters that cause a change in status code, content length, or response body.
Installation
git clone https://github.com/maK-/parameth.gitcd paramethpip install -r requirements.txt
Basic Usage
# GET parameter discoverypython parameth.py -u https://example.com/page.php# POST parameter discoverypython parameth.py -u https://example.com/api -X POST# With a custom wordlistpython parameth.py -u https://example.com/page.php -w params.txt
Key Features
- Supports GET and POST methods
- Compares responses to detect changes
- Custom wordlist support
- Simple, lightweight Python script
When to Use
Use parameth for quick, straightforward parameter discovery on individual endpoints. It is a good starting point when you need fast results without complex configuration.
🔗 GitHub
4. param-miner
param-miner is a Burp Suite extension that identifies hidden, unlinked parameters. It is particularly useful for finding web cache poisoning vulnerabilities.
Installation
- Open Burp Suite.
- Go to Extender → BApp Store.
- Search for "Param Miner".
- Click Install.
Alternatively, download the JAR from the GitHub releases and load it via Extender → Extensions → Add.
Basic Usage
- Passive scanning: Param Miner automatically learns parameter names from observed traffic.
- Active scanning: Right-click a request → Guess params → Guess GET parameters (or POST, cookies, headers).
- Cache poisoning: Use the Param Miner menu to test for web cache poisoning via unkeyed parameters.
Key Features
- Passive and active parameter discovery
- Supports GET, POST, cookies, and headers
- Web cache poisoning detection
- Integrates directly into Burp Suite
- Uses a large built-in wordlist
When to Use
Use param-miner when you are already working in Burp Suite and want passive discovery alongside active guessing. It is the go-to tool for web cache poisoning research.
🔗 GitHub
5. ParamPamPam
ParamPamPam is a Python tool for brute-discovering GET and POST parameters. It is designed to be fast and focused.
Installation
git clone https://github.com/cyberaz0r/ParamPamPam.gitcd ParamPamPampip install -r requirements.txt
Basic Usage
# GET parameter discoverypython ParamPamPam.py -u https://example.com/page.php# POST parameter discoverypython ParamPamPam.py -u https://example.com/api -X POST# Custom wordlist and threadspython ParamPamPam.py -u https://example.com/page.php -w params.txt -t 20
Key Features
- Fast, multi-threaded brute-forcing
- Supports GET and POST
- Custom wordlists
- Simple CLI interface
When to Use
Use ParamPamPam when you need a fast, no-frills parameter brute-forcer. It is ideal for quick checks on individual endpoints.
🔗 GitHub
6. Arjun
Arjun is an HTTP parameter discovery suite. It is one of the most comprehensive tools for finding hidden parameters, supporting GET, POST, JSON, and XML.
Installation
pip install arjun
Or clone from GitHub:
git clone https://github.com/s0md3v/Arjun.gitcd Arjunpython setup.py install
Basic Usage
# GET parameter discoveryarjun -u https://example.com/page.php# POST parameter discoveryarjun -u https://example.com/api -m POST# JSON parameter discoveryarjun -u https://example.com/api -m JSON# Multiple URLs from a filearjun -i urls.txt -o results.json
Key Features
- Supports GET, POST, JSON, XML
- Multi-threaded and fast
- Intelligent response analysis (status code, content length, reflection)
- Can use custom wordlists
- JSON output for automation
When to Use
Use Arjun when you need a thorough, multi-method parameter discovery suite. It is more comprehensive than parameth or ParamPamPam and is well-suited for serious assessments.
🔗 GitHub
7. ParamSpider
ParamSpider mines parameters from dark corners of web archives. It queries the Wayback Machine, Common Crawl, and other sources to find URLs with parameters.
Installation
git clone https://github.com/devanshbatham/ParamSpider.gitcd ParamSpiderpip install -r requirements.txt
Basic Usage
# Basic usagepython paramspider.py -d example.com# Save output to a filepython paramspider.py -d example.com -o params.txt# Exclude certain extensionspython paramspider.py -d example.com -e woff,css,js
Key Features
- Passive discovery from web archives
- No active requests to the target
- Extracts URLs with parameters
- Filters by extension
- Fast and lightweight
When to Use
Use ParamSpider when you want passive parameter discovery from historical data. It is perfect for the initial reconnaissance phase and for targets where active scanning is not authorized.
🔗 GitHub
8. x8
x8 is a hidden parameters discovery suite written in Rust. It is designed for high-speed brute-forcing.
Installation
# Using cargocargo install x8# Or download a precompiled binary from GitHub releases
Basic Usage
# Basic GET parameter discoveryx8 -u https://example.com/page.php# POST parameter discoveryx8 -u https://example.com/api -X POST# With a custom wordlist and concurrencyx8 -u https://example.com/page.php -w params.txt -c 50
Key Features
- Very fast (Rust)
- Supports GET and POST
- Multi-threaded
- Custom wordlists
- Simple CLI
When to Use
Use x8 when speed is critical and you need a lightweight, high-performance parameter brute-forcer.
🔗 GitHub
9. Comparison Table
| Tool | Language | Method | Passive/Active | Speed | Best For |
|---|---|---|---|---|---|
| parameth | Python | GET/POST | Active | Medium | Quick, simple discovery |
| param-miner | Java (Burp) | GET/POST/Cookies/Headers | Both | Medium | Burp users, cache poisoning |
| ParamPamPam | Python | GET/POST | Active | Fast | Fast brute-forcing |
| Arjun | Python | GET/POST/JSON/XML | Active | Fast | Comprehensive discovery |
| ParamSpider | Python | Archive mining | Passive | Fast | Passive, historical discovery |
| x8 | Rust | GET/POST | Active | Very fast | High-speed brute-forcing |
10. Best Practices & Workflow
- Start passive. Use ParamSpider to mine archives for existing parameters without touching the target.
- Move to active discovery. Use Arjun or x8 to brute-force parameters on endpoints of interest.
- Leverage Burp. If you use Burp Suite, enable param-miner for passive and active discovery, especially for cache poisoning.
- Use custom wordlists. Default wordlists are good, but custom wordlists tailored to the target (e.g., from JS files) improve results.
- Analyze responses carefully. Parameters that change status code, content length, or reflection are the most interesting.
- Test discovered parameters. Once found, test for injection, access control bypass, and other vulnerabilities.
- Document everything. Keep a record of discovered parameters and their effects for your report.
Example Workflow
# 1. Passive discovery with ParamSpiderpython paramspider.py -d example.com -o passive_params.txt# 2. Active discovery with Arjunarjun -u https://example.com/page.php -o arjun_results.json# 3. Fast brute-force with x8x8 -u https://example.com/page.php -w /usr/share/wordlists/params.txt -c 50 -o x8_results.txt# 4. Combine and deduplicatecat passive_params.txt arjun_results.txt x8_results.txt | sort -u > all_params.txt# 5. Test discovered parameters# Use ffuf, Burp, or custom scripts to test each parameter
11. Final Tips
- Combine tools. No single tool finds everything. Passive + active + Burp coverage gives the best results.
- Wordlists matter. A good parameter wordlist (e.g., from SecLists) dramatically improves active discovery.
- Watch for reflections. Parameters that reflect in the response are candidates for XSS.
- Check for cache poisoning. Unkeyed parameters can poison web caches—param-miner excels at this.
- Respect rate limits. Active brute-forcing can be noisy; use concurrency controls.
- Stay authorized. Always obtain written permission before scanning any system.
- Keep tools updated. The parameter discovery landscape evolves quickly.
Official Resources:
- parameth: github.com/maK-/parameth
- param-miner: github.com/PortSwigger/param-miner
- ParamPamPam: github.com/cyberaz0r/ParamPamPam
- Arjun: github.com/s0md3v/Arjun
- ParamSpider: github.com/devanshbatham/ParamSpider
- x8: github.com/Sh1Yo/x8
- SecLists: github.com/danielmiessler/SecLists
Remember: Parameter discovery is a powerful reconnaissance technique. Use it responsibly, stay within scope, and always obtain proper authorization before testing any system.
Author
Discussion · 0
No comments yet — start the discussion.
Sign in to join the discussion.