Skip to content
Recon Guide · By Masaud Ahmed

Complete Bug Bounty Recon Workflow for Hunters

Bug Bounty / 12 min read

This guide provides a comprehensive reconnaissance workflow for bug bounty hunters and penetration testers. Follow these steps to systematically discover vulnerabilities in web applications.

At masaudsec.com, we specialize in cybersecurity, ethical hacking, and penetration testing services. Contact us for professional security assessments.

TL;DR: Reconnaissance is the process of gathering information about a target system before testing. The workflow below moves from passive subdomain discovery to live host verification, endpoint collection, filtering, automated scanning with Nuclei, and finally manual testing in Burp Suite.

Recon Workflow Steps

The complete workflow runs through ten steps. Each one builds on the last — run them in order on your target domain to get a clean, testable attack surface.

01. Subdomain Enumeration

Use multiple tools to passively collect subdomains. More tools = better coverage.

subfinder -d crunch.co.uk -o subfinder.txt
assetfinder --subs-only crunch.co.uk | tee assetfinder.txt
findomain -t crunch.co.uk -q | tee find-domain.txt

What it does: These tools collect subdomains by querying different sources like crt.sh, threat intel feeds, and APIs.

Output: Multiple text files containing discovered subdomains.

02. Merge and De-duplicate

Combine all subdomains and remove duplicates to form a master list.

cat *.txt > all.txt && sort -u all.txt -o all.txt

Why? Eliminates duplicate entries from different tools for cleaner results.

Output: all.txt with unique subdomains.

03. Check for Live Subdomains

Use Httpx to see which subdomains are active and responding.

cat all.txt | httpx -l all.txt -o live_domains.txt

Why? Only active domains are worth testing further.

Output: live_domains.txt containing active subdomains.

Pro Tip: Httpx can also grab versions and technologies with additional flags like -title -tech-detect -status-code

04. Collect URLs and Endpoints

Use Waymore and Katana to discover hidden or archived endpoints.

waymore -i "crunch.co.uk" -mode U -oU waymore.txt
pip install qurl
cat live_domains.txt | katana -f qurl -silent -kf all -jc -aff -d 5 -o katana-param.txt

How it works: Waymore pulls from archives while Katana performs live crawling.

Output: Two files with discovered URLs and endpoints.

Note: Katana requires live domains list while Waymore only needs the main domain.

05. Find Sensitive or Hidden Files

Look for interesting file types which may expose data.

grep -E -i -o '\S+\.(cobak|backup|swp|old|db|sql|asp|aspx|aspx~|asp~|py|py~|rb|rb~|php|php~|bak|bkp|cache|cgi|conf|csv|html|inc|jar|js|json|jsp|jsp~|lock|log|r(ar|)\.old|sql|sql\.gz|sql\.zip|sql\.tar\.gz|sql~|swp|swp~|tar|tar\.bz2|tar\.gz|txt|wadl|zip|log|xml|json|\.secret$|\.yml$|\.env$|\.config$|\.conf$|\.ini$|\.htaccess$|\.htpasswd$|\.pem$|\.key$|\.crt$|\.cer$|\.pfx$|\.p12$|\.tmp$|\.temp$|\.dump$|\.passwd$|\.shadow$|\.git$|\.svn$|\.DS_Store$|\.idea$|\.vscode$|\.bash_history$|\.zsh_history$|\.ssh$|\.id_rsa$|\.id_dsa$|\.ppk$|\.aws$|\.boto$|\.credentials$|\.token$|\.session$|\.pyc$|\.jar$|\.war$|\.class$|\.apk$|\.ipa$|\.dex$|\.plist$|\.cfg$|\.cnf$|\.properties$|\.sql.gz$|\.tar.gz$|\.backup.sql$|\.backup.gz$|\.access.log$|\.error.log)\b' "waymore.txt" "katana-param.txt" | sort -u > finding.txt

Why? These files often contain sensitive information like credentials or source code.

Output: finding.txt containing potentially sensitive file URLs.

06. Clean URLs (Remove Static Files)

Filter out unimportant file types (images, fonts, etc.).

cat waymore.txt katana-param.txt | sort -u | egrep -v '\.(css|png|blog|utm_source|utm_content|utm_campaign|utm_medium|jpeg|jpg|svg|gifs|tif|tiff|png|ttf|woff|woff2|ico|pdf|svg|txt|gif|wolf)$' > waymore-katana-unfilter-urls.txt

Why? Focus on dynamic pages that are more likely to contain vulnerabilities.

Output: waymore-katana-unfilter-urls.txt with useful endpoints only.

07. Filter Live URLs

Filter out dead URLs using Httpx again.

cat waymore-katana-unfilter-urls.txt | httpx -t 150 -rl 150 -o waymore-katana-filter-urls.txt

Why? Ensure you're only testing URLs that are accessible.

Output: waymore-katana-filter-urls.txt with alive and useful links for testing.

08. Extract Parameterized URLs

Grab URLs with parameters (=) – useful for injection testing.

grep -a = "waymore-katana-filter-urls.txt" >> parameters_with_equal.txt

Why? Parameterized URLs are ideal for testing SQLi, XSS, LFI, and other vulnerabilities.

Output: parameters_with_equal.txt containing URLs with parameters.

09. Scan with Nuclei

Use Nuclei to run automated vulnerability scans.

nuclei -l live_domains.txt -o nuclei-result.txt
nuclei -u example.com -o result.txt

How it works: Nuclei uses community templates to check for known vulnerabilities.

Output: nuclei-result.txt containing vulnerability findings.

10. Send to Burp for Manual Testing

Send all live URLs to Burp Suite using curl and Parallel.

cat waymore-katana-unfilter-urls.txt | parallel -j 10 'curl --proxy http://127.0.0.1:8080 -sk {}' >> /dev/null
cat waymore-katana-filter-urls.txt | parallel -j 10 'curl --proxy http://127.0.0.1:8080 -sk {}' >> /dev/null

Why? These URLs will appear in Burp Suite's HTTP history for manual analysis.

Result: All URLs loaded into Burp Suite for in-depth testing.

Download All Commands

Get all these commands in a single script file for easy execution.

Why Automation in Bug Bounty?

Automation is crucial in bug bounty hunting for several reasons:

Frequently Asked Questions

What is bug bounty hunting?

Bug bounty hunting is the process of finding and reporting vulnerabilities in software, websites, or applications in exchange for rewards. Companies run bug bounty programs to crowdsource security testing from ethical hackers.

Why is reconnaissance important in bug bounty?

Reconnaissance is the foundation of successful bug hunting. It helps you:

  • 1Discover all possible attack surfaces
  • 2Find hidden or forgotten assets
  • 3Identify outdated software versions
  • 4Spot misconfigurations
  • 5Gather intelligence for targeted attacks

Good recon often leads to finding the most valuable bugs.

How long does it take to learn bug bounty?

The learning curve varies, but typically:

  • 13–6 months: Basic understanding of web vulnerabilities
  • 26–12 months: Finding your first valid bugs
  • 31–2 years: Consistently finding high-value vulnerabilities

Continuous learning and practice are key. My free course can help you get started faster.

What tools should I start with for bug bounty?

Start with these essential tools:

  • 1Browser: Chrome/Firefox with developer tools
  • 2Proxy: Burp Suite or OWASP ZAP
  • 3Scanner: Nuclei for automated vulnerability scanning
  • 4Crawler: Tools like Katana for endpoint discovery

Ready to Level Up Your Recon?

Master this workflow hands-on with 1-on-1 mentorship. Learn exactly how working bug bounty hunters automate recon and turn findings into real reports.

Join the Mentorship Program
Enrol now Programs
Chat on WhatsApp