Screenshots: A Complete Guide to Visual Reconnaissance Tools
Screenshots: A Complete Guide to Visual Reconnaissance Tools
Visual reconnaissance is a crucial phase in penetration testing, bug bounty hunting, and attack surface mapping. Taking screenshots of web applications, RDP services, and VNC endpoints allows you to quickly triage large numbers of hosts, identify interesting targets, and document findings. This guide covers ten powerful tools for capturing and analyzing screenshots, from automated web screenshot utilities to specialized tools for extracting passwords from pixelized images.
⚠️ Legal and ethical notice: These tools interact with target systems, often making HTTP requests or connecting to services. Only use them against systems you own or have explicit written authorization to test. Unauthorized scanning and screenshotting may violate laws and terms of service.
Table of Contents
- Why Screenshots Matter in Recon
- Tool Overview
- EyeWitness
- aquatone
- screenshoteer
- gowitness
- WitnessMe
- eyeballer
- scrying
- Depix
- httpscreenshot
- invisible-playwright
- Comparison Table
- Best Practices & Workflow
- Final Tips
Why Screenshots Matter in Recon
When you have hundreds or thousands of hosts to assess, manually visiting each one is impractical. Screenshots provide a fast, visual way to:
- Triage targets – Identify login panels, admin interfaces, default installations, and error pages at a glance.
- Document findings – Capture evidence of exposed services for reports.
- Spot anomalies – Notice unusual applications, custom software, or misconfigurations.
- Analyze at scale – Use machine learning to classify screenshots (e.g., eyeballer).
- Recover information – Extract passwords from pixelized screenshots (Depix).
The tools in this guide cover the entire screenshot workflow: capture, organization, analysis, and extraction.
Tool Overview
| Tool | Language | Primary Purpose | Best For |
|---|---|---|---|
| EyeWitness | Python | Web screenshots + server headers | Comprehensive web triage |
| aquatone | Go | Visual inspection of many hosts | Quick HTTP attack surface overview |
| screenshoteer | Node.js | CLI screenshots + mobile emulation | Simple, scriptable captures |
| gowitness | Go | Web screenshots using Chrome Headless | Fast, modern screenshotting |
| WitnessMe | Python | Web inventory + screenshots | Detailed web inventory with extras |
| eyeballer | Python | CNN for analyzing pentest screenshots | Automated classification of screenshots |
| scrying | Go | RDP, web, VNC screenshots | Multi-protocol visual recon |
| Depix | Python | Recover passwords from pixelized screenshots | Digital forensics, CTFs |
| httpscreenshot | Python | Screenshots + HTML of many websites | Bulk capture with HTML saving |
| invisible-playwright | Node.js | Stealth Playwright wrapper | Bypassing anti-bot detection |
EyeWitness
EyeWitness is designed to take screenshots of websites, provide server header info, and identify default credentials if possible. It is a staple in the penetration tester's toolkit.
Installation
git clone https://github.com/RedSiege/EyeWitness.gitcd EyeWitness/Python/setupsudo ./setup.sh
Basic Usage
# Single URLpython EyeWitness.py -f urls.txt --web# From a file with URLspython EyeWitness.py -f urls.txt -d output_dir --web# With a timeout and threadspython EyeWitness.py -f urls.txt --web -t 10 --timeout 15
Key Features
- Takes screenshots of web pages
- Captures server headers
- Attempts to identify default credentials
- Generates an HTML report with thumbnails
- Supports HTTP and HTTPS
- Can parse Nmap XML output for targets
When to Use
Use EyeWitness when you need a comprehensive visual overview of a large list of web hosts, along with server information and basic credential testing. It is ideal for the initial triage phase of a penetration test.
aquatone
Aquatone is a tool for visual inspection of websites across a large number of hosts. It is convenient for quickly gaining an overview of HTTP-based attack surface.
Installation
go install github.com/michenriksen/aquatone@latest
Basic Usage
# From a list of subdomainscat subdomains.txt | aquatone -out aquatone_report# With custom portscat hosts.txt | aquatone -ports 80,443,8080,8443 -out report# Use a proxycat hosts.txt | aquatone -proxy http://127.0.0.1:8080 -out report
Key Features
- Screenshots of web pages
- Groups similar pages using clustering
- Generates an HTML report with a gallery view
- Supports custom ports and protocols
- Integrates with Nmap for port scanning
- Can use a proxy
When to Use
Use aquatone when you want a quick, visual overview of a large attack surface. Its clustering feature helps identify similar applications across many hosts.
screenshoteer
screenshoteer makes website screenshots and mobile emulations from the command line.
Installation
npm install -g screenshoteer
Basic Usage
# Basic screenshotscreenshoteer --url https://example.com --output screenshot.png# Mobile emulation (iPhone X)screenshoteer --url https://example.com --mobile --output mobile.png# Full page screenshotscreenshoteer --url https://example.com --full-page --output full.png
Key Features
- Simple CLI interface
- Mobile device emulation
- Full-page screenshots
- Custom viewport sizes
- Supports HTTP authentication
When to Use
Use screenshoteer when you need quick, scriptable screenshots without a heavy framework. It is ideal for ad-hoc captures and integration into shell scripts.
gowitness
gowitness is a Golang web screenshot utility using Chrome Headless. It is fast, modern, and designed for scale.
Installation
go install github.com/sensepost/gowitness@latest
Basic Usage
# Single URLgowitness single https://example.com# Scan a file of URLsgowitness scan file -f urls.txt --screenshot-path screenshots/# Scan a CIDR rangegowitness scan cidr -c 192.168.1.0/24 --screenshot-path screenshots/# Scan a network range with portsgowitness scan cidr -c 10.0.0.0/8 -p 80,443,8080
Key Features
- Fast, concurrent screenshotting
- Uses Chrome Headless for accurate rendering
- Stores results in a local database
- Generates an HTML report with search and filtering
- Supports Nmap XML input
- Can scan CIDR ranges, files, and single URLs
When to Use
Use gowitness when you need a modern, fast, and scalable screenshot tool. It is excellent for large-scale recon and integrates well with other tools.
WitnessMe
WitnessMe is a web inventory tool that takes screenshots of webpages using Pyppeteer (headless Chrome/Chromium) and provides extra features to make life easier.
Installation
git clone https://github.com/byt3bl33d3r/WitnessMecd WitnessMepip install -r requirements.txt
Basic Usage
# From a file of URLspython WitnessMe.py -f urls.txt -o output_dir# With a specific timeoutpython WitnessMe.py -f urls.txt -o output_dir --timeout 30# Use a proxypython WitnessMe.py -f urls.txt -o output_dir --proxy http://127.0.0.1:8080
Key Features
- Takes screenshots using headless Chrome
- Captures HTTP headers and page titles
- Identifies default credentials (like EyeWitness)
- Generates a detailed HTML report
- Supports proxy usage
- Can parse Nmap XML
When to Use
Use WitnessMe when you want a feature-rich inventory tool that goes beyond simple screenshots. It is a solid alternative to EyeWitness with a modern headless browser backend.
eyeballer
eyeballer is a convolutional neural network for analyzing pentest screenshots. It automatically classifies screenshots into categories like "login page", "homepage", "error", etc.
Installation
git clone https://github.com/BishopFox/eyeballercd eyeballerpip install -r requirements.txt
Basic Usage
# Predict on a directory of screenshotseyeballer predict --directory screenshots/ --output results.csv# Train a new model (advanced)eyeballer train --directory training_data/
Key Features
- Pre-trained CNN model for classifying screenshots
- Identifies categories: login pages, homepages, errors, etc.
- Outputs CSV with predictions and confidence scores
- Can be retrained on custom data
- Speeds up triage of large screenshot sets
When to Use
Use eyeballer after capturing hundreds of screenshots. It helps you quickly find interesting pages (like login panels) without manually reviewing every image.
scrying
scrying is a tool for collecting RDP, web, and VNC screenshots all in one place.
Installation
go install github.com/nccgroup/scrying@latest
Basic Usage
# Scan a list of targetsscrying -t targets.txt -o output_dir# Specify protocolsscrying -t targets.txt -p rdp,http,vnc -o output_dir# Use a proxyscrying -t targets.txt --proxy http://127.0.0.1:8080 -o output_dir
Key Features
- Captures screenshots from RDP, web, and VNC services
- Multi-threaded for speed
- Generates an HTML report
- Supports proxy usage
- Can parse Nmap XML
When to Use
Use scrying when your reconnaissance includes non-HTTP services like RDP and VNC. It provides a unified visual overview across protocols.
Depix
Depix recovers passwords from pixelized screenshots. It is a specialized tool for digital forensics and CTFs.
Installation
git clone https://github.com/beurtschipper/Depixcd Depixpip install -r requirements.txt
Basic Usage
python depix.py -p pixelized.png -s search_image.png -o output.png
Key Features
- Recovers text from pixelized (mosaic) images
- Uses a search image to match blocks
- Works on screenshots where text has been pixelated
- Useful for CTFs and forensic investigations
When to Use
Use Depix when you encounter a pixelized screenshot and need to recover the original text. It is not a general-purpose screenshot tool but a specialized recovery utility.
httpscreenshot
httpscreenshot is a tool for grabbing screenshots and HTML of large numbers of websites.
Installation
git clone https://github.com/aboul3la/httpscreenshotcd httpscreenshotpip install -r requirements.txt
Basic Usage
python httpscreenshot.py -f urls.txt -o output_dir# Save HTML as wellpython httpscreenshot.py -f urls.txt -o output_dir --html
Key Features
- Takes screenshots of many websites
- Saves HTML source code
- Supports HTTP and HTTPS
- Multi-threaded
- Generates an HTML report
When to Use
Use httpscreenshot when you need both screenshots and HTML source for a large list of URLs. It is useful for offline analysis and archiving.
invisible-playwright
invisible-playwright is a Playwright wrapper for a stealth-patched Firefox 150 binary. It is useful for screenshotting and recon against targets with anti-bot detection (reCAPTCHA v3, FingerprintPro, Cloudflare).
Installation
npm install invisible-playwright
Basic Usage
const { firefox } = require('invisible-playwright');(async () => {const browser = await firefox.launch({ headless: true });const page = await browser.newPage();await page.goto('https://example.com');await page.screenshot({ path: 'screenshot.png' });await browser.close();})();
Live JavaScript preview
Key Features
- Stealth-patched Firefox binary
- Bypasses common anti-bot detection
- Full Playwright API
- Supports screenshots, navigation, and interaction
- Ideal for targets protected by Cloudflare, reCAPTCHA v3, etc.
When to Use
Use invisible-playwright when standard screenshot tools fail due to anti-bot protections. It is essential for modern web applications that block headless browsers.
Comparison Table
| Tool | Language | Protocols | Anti-Bot | Analysis | Output |
|---|---|---|---|---|---|
| EyeWitness | Python | HTTP/HTTPS | No | Default creds | HTML report |
| aquatone | Go | HTTP/HTTPS | No | Clustering | HTML report |
| screenshoteer | Node.js | HTTP/HTTPS | No | None | PNG files |
| gowitness | Go | HTTP/HTTPS | No | Database | HTML report |
| WitnessMe | Python | HTTP/HTTPS | No | Default creds | HTML report |
| eyeballer | Python | N/A (post-processing) | N/A | CNN classification | CSV |
| scrying | Go | RDP, HTTP, VNC | No | None | HTML report |
| Depix | Python | N/A (post-processing) | N/A | Text recovery | PNG |
| httpscreenshot | Python | HTTP/HTTPS | No | HTML saving | HTML report |
| invisible-playwright | Node.js | HTTP/HTTPS | Yes | None | PNG files |
Best Practices & Workflow
- Start with a target list. Use subdomain enumeration tools (Subfinder, Amass) to generate a list of hosts.
- Resolve and filter. Use httpx or dnsx to find live web servers.
- Choose the right tool. For large-scale HTTP triage, use gowitness or aquatone. For RDP/VNC, use scrying. For anti-bot targets, use invisible-playwright.
- Capture screenshots. Run your chosen tool with appropriate concurrency and timeouts.
- Analyze. If you have hundreds of screenshots, run eyeballer to classify them and find interesting pages.
- Extract information. Use Depix if you encounter pixelized passwords.
- Document. Save screenshots and reports for your findings.
Example Workflow
# 1. Enumerate subdomainssubfinder -d example.com -o subdomains.txt# 2. Find live web serverscat subdomains.txt | httpx -silent -o live_urls.txt# 3. Take screenshots with gowitnessgowitness scan file -f live_urls.txt --screenshot-path screenshots/# 4. Classify with eyeballereyeballer predict --directory screenshots/ --output results.csv# 5. Review interesting pages# Look for login pages, admin panels, etc.
Final Tips
- Use headless Chrome. Modern tools like gowitness and WitnessMe use Chrome Headless for accurate rendering.
- Respect rate limits. Taking screenshots of thousands of hosts can be resource-intensive; adjust concurrency and timeouts.
- Handle anti-bot protections. When targets block headless browsers, use invisible-playwright or similar stealth tools.
- Combine with other recon. Screenshots are most powerful when combined with port scanning, service detection, and vulnerability scanning.
- Keep tools updated. The screenshot landscape evolves; new anti-bot techniques require new bypass methods.
- Document everything. Screenshots are evidence; organize them logically for reporting.
Official Resources:
- EyeWitness: github.com/RedSiege/EyeWitness
- aquatone: github.com/michenriksen/aquatone
- screenshoteer: github.com/virejdasani/screenshoteer
- gowitness: github.com/sensepost/gowitness
- WitnessMe: github.com/byt3bl33d3r/WitnessMe
- eyeballer: github.com/BishopFox/eyeballer
- scrying: github.com/nccgroup/scrying
- Depix: github.com/beurtschipper/Depix
- httpscreenshot: github.com/aboul3la/httpscreenshot
- invisible-playwright: npmjs.com/package/invisible-playwright
Remember: Screenshots are a powerful reconnaissance technique. Use them 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.