WhatWeb

Information Gathering

Beginnerlow risk

WhatWeb identifies websites by fingerprinting their technologies. It answers the question 'What is that website?' by detecting content management systems (CMS), blogging platforms, analytics packages, JavaScript libraries, web servers, embedded devices, and over 1800 other web technologies using its plugin architecture.

Installation

sudo apt install whatweb

Basic Syntax

whatweb [options] <target>

Quick Facts

Full Name

WhatWeb

License

GNU GPL v3

Author

Andrew Horton (urbanadventurer)

Written In

Ruby

Platforms

Linux, macOS, Windows (via Ruby)

Category

Web Fingerprinting Tool

Plugins

1800+ detection plugins

GitHub

github.com/urbanadventurer/WhatWeb

Tool Overview

WhatWeb is a free, open-source website fingerprinting tool that identifies technologies used by websites and web applications. It answers the fundamental question: 'What is that website?' by detecting content management systems (CMS), JavaScript libraries, web frameworks, analytics tools, web servers, and over 1800 other technologies through its extensive plugin architecture.

Created by Andrew Horton (urbanadventurer), WhatWeb uses multiple detection techniques including HTTP header analysis, HTML signature matching, URL pattern recognition, meta tag analysis, and cookie inspection. Each technology has its own dedicated plugin, making WhatWeb one of the most comprehensive technology detection tools available.

WhatWeb is pre-installed on Kali Linux and is an essential tool in every penetration tester's reconnaissance workflow. It helps security professionals understand a target's technology stack before launching further testing with tools like Nikto, Gobuster, or SQLMap. The tool supports aggressive scanning modes for deep version detection, bulk scanning from URL lists, and multiple output formats including JSON, XML, and HTML for automation and reporting.

Common Commands

whatweb example.comBasic scan — passive and regular detection of the target website's technologies

whatweb -v example.comVerbose output — shows detailed information about each plugin match and detection method

whatweb -a 3 example.comAggressive scan level 3 — makes more HTTP requests to probe deeply into plugins and extract version numbers

whatweb -a 4 example.comHeavy aggression level 4 — maximum probing with extensive requests for maximum detail

whatweb --log-json=results.json example.comJSON output — save results in JSON format for programmatic analysis and automation pipelines

whatweb --log-xml=results.xml example.comXML output — save results in XML format for integration with SIEM tools and reporting platforms

whatweb --log-html=results.html example.comHTML output — generate a human-readable HTML report of detected technologies

whatweb --log-sql=results.sql example.comSQL output — store results in SQL format for database import and querying

whatweb -i targets.txtBulk scan — read target URLs from a text file and scan each one

whatweb --input-file=urls.txt --log-json=output.jsonBulk scan with JSON — scan multiple URLs and save all results as JSON

whatweb --color=never example.comNo color output — disable ANSI color codes for clean piping into other tools

whatweb --user-agent='Mozilla/5.0' example.comCustom user agent — set a custom User-Agent header to avoid detection

whatweb --proxy=http://127.0.0.1:8080 example.comProxy support — route traffic through Burp Suite or ZAP for analysis

whatweb --wait=2 example.comRate limiting — wait 2 seconds between requests to avoid overwhelming the server

whatweb --threads=5 example.comThread control — use 5 concurrent threads for faster scanning

Step-by-Step Guide

1Install WhatWeb on your system using your package manager (sudo apt install whatweb on Kali Linux)
2Identify the target website URL you want to fingerprint (ensure you have authorization to scan)
3Run a basic scan: whatweb example.com to see what technologies are detected
4Increase aggression level with -a 2 or -a 3 to probe deeper and extract version numbers
5Save results in JSON format using --log-json=output.json for later analysis or automation
6Use --input-file=targets.txt to scan multiple URLs in bulk from a text file
7Review the output to identify CMS platforms, web servers, JavaScript libraries, and analytics tools
8Cross-reference detected software versions with known vulnerabilities in exploit databases
9Combine with tools like Nikto for vulnerability scanning and Gobuster for directory enumeration

Warnings

Using aggressive scanning modes (-a 3 or -a 4) generates a high volume of HTTP requests and may slow down the target server
Certain aggressive probes might trigger a Web Application Firewall (WAF) block and lock you out of the target
Always obtain explicit written authorization before scanning any website you do not own
Aggressive scans are more likely to be detected by intrusion detection systems and logged by web servers
Respect robots.txt and the target site's terms of service regarding automated traffic
Scanning government, military, or financial websites without authorization can result in legal consequences

Use Cases

CMS Detection

Identify WordPress, Joomla, Drupal, Magento, and hundreds of other content management systems running on target websites.

Web Server Identification

Detect Apache, Nginx, IIS, LiteSpeed, and other web server software along with their exact version numbers.

JavaScript Library Detection

Identify jQuery, React, Angular, Vue.js, Bootstrap, and other front-end frameworks and libraries in use.

Analytics Detection

Discover Google Analytics, Matomo, Hotjar, Mixpanel, and other analytics and tracking tools embedded in websites.

Version Fingerprinting

Extract exact version numbers of detected technologies to cross-reference with known CVEs and vulnerability databases.

Technology Inventory

Build a complete technology stack profile of a target organization for security assessments and competitive analysis.

Key Features

1800+ Detection Plugins: Extensive plugin library covering CMS platforms, JavaScript libraries, web servers, analytics tools, and more.
Four Aggression Levels: Configurable scanning intensity from passive (level 1) to heavy (level 4) for different testing scenarios.
Multiple Output Formats: Save results in JSON, XML, HTML, SQL, or binary format for automation, reporting, and integration.
Bulk Scanning: Scan multiple URLs from text files with -i flag for efficient large-scale technology inventory.
Proxy Support: Route traffic through HTTP proxies for analysis with Burp Suite, ZAP, or other intercepting tools.
Custom Headers: Add custom HTTP headers for authenticated scanning and WAF bypass techniques.
Rate Limiting: Control scanning speed with --wait and --threads to avoid overwhelming target servers.
Link Following: Discover technologies on linked pages with configurable depth using --find-links.

Comparison

WhatWeb vs httpx vs Wappalyzer — Feature Depth

Feature	WhatWeb	httpx	Wappalyzer
Primary Purpose	Deep fingerprinting	Fast HTTP probing	Browser tech check
Detection Plugins	1800+	Wappalyzer-based set	2500+ signatures
Version Extraction	Yes (a-3/a-4)	Partial	Partial
Bulk Scanning	Yes (-i file)	Yes (excellent)	Limited
Speed at Scale	Moderate	Very fast	Slow
CLI Automation	Yes	Yes	No (extension)
Best For	Detailed per-target	Mass triage	One-off checks

WhatWeb Aggression Levels — Speed vs Detail

Feature	Level 1	Level 2	Level 3	Level 4
HTTP Requests	Single request	A few extra	Many	Maximum
Version Detection	Rarely	Sometimes	Usually	Aggressively
Stealth	High	Good	Low	Very low
WAF Trigger Risk	Minimal	Low	Moderate	High
Speed	Fastest	Fast	Slower	Slowest
Recommended For	Passive recon	General use	Authorized pentest	Lab only

WhatWeb vs Nmap NSE — Web Recon Overlap

Feature	WhatWeb	Nmap NSE
Web Tech Detection	Specialized (1800+)	Basic (http-* scripts)
Port Scanning	No	Yes (core strength)
CMS Version Detection	Detailed	Limited
Output Formats	JSON/XML/HTML/SQL	Normal/XML/greppable
Scan Scope	Web layer only	Full network stack
Typical Order	After port discovery	First (find ports)

Output Formats — When to Use Which

Feature	JSON	XML	HTML	Terminal
Automation	Best	Good	Poor	Poor
Human Readable	Moderate	Moderate	Best	Good
SIEM Integration	Good	Best	No	No
Reporting to Clients	No	No	Best	No
Flag	--log-json	--log-xml	--log-html	(default)

Best Practices

Always get explicit written authorization before scanning any host you do not own — passive fingerprinting can still be treated as unauthorized access.:
Start with a passive scan (default -a 1) to build a baseline before escalating to aggressive probing.:
Escalate to -a 3 only when you need version numbers, and reserve -a 4 for lab environments you fully control.:
Save every scan with --log-json so results are reproducible and machine-readable for later analysis.:
Adopt a consistent output naming convention that includes the target and date, e.g. example.com-2026-07-16.json.:
Use --wait=2 or higher against production sites to avoid overwhelming the server or tripping rate limits.:
Route scans through a proxy (--proxy=http://127.0.0.1:8080) when you want Burp Suite or ZAP to log every request.:
Set a realistic User-Agent for authorized engagements so your traffic is attributable rather than disguised as a scanner.:
Detect the WAF with wafw00f before aggressive scanning so you can plan around Cloudflare, Akamai, or Imperva.:
Verify high-impact findings manually with verbose mode (-v) before putting them in a report.:
Cross-reference detected versions against CVE databases to turn a technology list into an actionable risk picture.:
Feed WhatWeb output into the next stage: Nikto for server flaws, Gobuster for content discovery, WPScan for WordPress.:
Scan both the apex domain and its subdomains — enumerate first with Subfinder or Amass, then fingerprint each host.:
Prefer bulk scanning with --input-file for large scopes instead of running WhatWeb one host at a time.:
Tune --threads to the environment: raise it for local labs, keep it modest against shared production infrastructure.:
Scan the correct scheme — run both http:// and https:// because they can reveal different stacks and redirects.:
Use --use-plugins to focus a scan when you only care about one technology (e.g. WordPress) for faster results.:
Keep WhatWeb updated so its 1800+ plugins recognize current framework and CMS versions.:
Pair WhatWeb with a browser-based detector for JavaScript-heavy single-page apps it cannot fingerprint alone.:
Record the exact command and timestamp for each scan so findings are defensible during reporting.:
Respect robots.txt and the target's terms of service, especially for compliance-driven assessments.:
Combine WhatWeb technology data with Nmap service detection for a full infrastructure picture.:
Store results in structured formats (JSON/SQL) so you can diff technology stacks over time and catch drift.:
Treat false positives as expected — generic signatures match shared libraries, so confirm before acting.:
Limit aggressive scanning windows to agreed maintenance times to minimize impact on live users.:
Document WAF and CDN presence in your notes so later tools account for filtering and cached responses.:
Never run -a 4 against production; the request volume can degrade service and trigger abuse protection.:
Sanitize logs before sharing — scan output can contain internal hostnames, tokens, or session identifiers.:

Common Errors

whatweb: command not found

Install it with sudo apt install whatweb (Debian/Kali/Ubuntu), brew install whatweb (macOS), or clone the repo and run ./whatweb directly.

Timeout error / connection timed out

Increase the timeout with --open-timeout=30 and --read-timeout=60, confirm the host is reachable with ping or curl, and check whether a firewall is blocking you.

SSL_connect returned=1 errno=0 (certificate verify failed)

WhatWeb ignores certificate errors by default in recent versions; if it does not, verify the site loads in a browser and confirm you are targeting the right host. The warning is safe to ignore for fingerprinting.

No results / empty output for a live site

Re-run with -a 3 for deep probing. If the site is a single-page app, WhatWeb cannot execute JavaScript — pair it with a browser tool like Wappalyzer.

Every request returns [403 Forbidden]

Set a browser User-Agent with --user-agent='Mozilla/5.0 ...', slow down with --wait=3, and route through a proxy. Detect the WAF first with wafw00f.

getaddrinfo: Name or service not known

Verify the domain with dig or nslookup, check /etc/resolv.conf, and make sure you included a resolvable hostname rather than a placeholder like example.local.

Connection refused

Confirm the web port is open with nmap -p 80,443, and specify the correct scheme (http:// vs https://) and port in the URL.

Ruby / gem load errors on non-Kali systems

Install Ruby and run bundle install inside the WhatWeb directory, or use the packaged version (apt/brew) which bundles dependencies.

Too many redirects

Raise the ceiling with --max-redirects=10, or target the final URL directly. HTTP-to-HTTPS loops usually mean you should scan the https:// URL.

Scan is extremely slow across many hosts

Increase concurrency with --threads=25 (or higher for local labs), and drop the aggression level to 1 or 2 for the first pass.

Character encoding / invalid byte sequence in UTF-8

Update to the latest WhatWeb version where encoding handling is improved, and add --no-errors to suppress noise while still capturing results.

--log-json produces an empty or malformed file

Let the scan finish, write to a fresh filename, and validate the JSON afterward. Use one log flag per format rather than mixing stdout redirection with --log-json.

Proxy connection failed

Confirm the proxy is running and matches the port (default Burp is 127.0.0.1:8080), then re-run with --proxy=http://127.0.0.1:8080.

Detected technologies look wrong (false positives)

Confirm findings with verbose mode (-v) to see which pattern triggered the match, and cross-check with a second tool before reporting.

Permission denied when writing log file

Write to a path you own such as ./results.json or ~/scans/, or adjust directory permissions.

WhatWeb hangs and never returns

Set explicit --open-timeout and --read-timeout values, and interrupt with Ctrl+C if a single host stalls the queue.

Only the web server is detected, no CMS or apps

Escalate to -a 3 (authorized targets only) so WhatWeb sends the follow-up requests needed to identify the CMS and version.

URL parsing error / invalid URI

Quote the URL, URL-encode special characters, and always include http:// or https://.

wget/curl works but WhatWeb is blocked

Match a real browser with --user-agent, add realistic headers via --header, and reduce request rate with --wait.

IPv6 target not scanned

Verify IPv6 connectivity, or target the IPv4 address explicitly. Confirm reachability with ping6 first.

Results differ between runs

Run several passes and aggregate, and note in your report that the target sits behind a load balancer or CDN.

Cannot scan a site behind login

Pass a session cookie or token with --header='Cookie: session=...' or --header='Authorization: Bearer ...' after authenticating manually.

gem install whatweb fails on Windows

Install Ruby+Devkit, or run WhatWeb inside WSL2/Kali where dependencies are packaged. Cloning the repo and running ./whatweb under WSL is the most reliable path.

Aggressive scan triggered an account/IP ban

Drop to -a 1, add --wait, and confirm you have written authorization before any active scanning. Never run heavy aggression against production without permission.

Learning Path

Related Tools

Nikto

Web Application

Web server scanner that tests for vulnerabilities, misconfigurations, and dangerous files.

Nmap

Information Gathering

Network mapper for port scanning and service detection.

Gobuster

Web Application

Directory and subdomain brute-forcer.

WPScan

Web Application

WordPress-specific security scanner.

Burp Suite

Web Application

Comprehensive web application security testing platform.

WAFW00F

Web Application

Web Application Firewall detection tool.

Subfinder

Information Gathering

Subdomain discovery tool.

Amass

Information Gathering

In-depth attack surface mapping tool.

Frequently Asked Questions

What is WhatWeb?

WhatWeb is a free, open-source command-line tool that identifies technologies on websites — CMS platforms, web servers, JavaScript libraries, analytics tools, and 1800+ other technologies. Pre-installed on Kali Linux, it uses four aggression levels and multiple output formats (JSON, XML, HTML) for automation.

What does WhatWeb do?

WhatWeb fingerprints websites by analyzing HTTP headers, HTML content, URL patterns, meta tags, and cookies. It detects CMS platforms, web servers, JavaScript libraries, and analytics tools. Supports four aggression levels and outputs results in JSON, XML, HTML, and SQL formats for automation.

What is WhatWeb used for?

WhatWeb is used for technology reconnaissance during penetration testing, bug bounty hunting, and security assessments. It identifies the technology stack before further testing with tools like [Nikto](/tools/nikto), [Gobuster](/tools/gobuster), or [SQLMap](/tools/sqlmap). Its JSON output enables automated workflows and integration with security platforms.

How to install WhatWeb?

On Kali Linux, WhatWeb is pre-installed. To install or update: `sudo apt install whatweb`. On macOS: `brew install whatweb`. On other systems: `git clone https://github.com/urbanadventurer/WhatWeb.git`. Windows users need Ruby installed first, then `gem install whatweb`.

How to use WhatWeb?

Run `whatweb example.com` for a basic scan. For deeper detection: `whatweb -a 3 example.com`. Save JSON results: `whatweb --log-json=results.json example.com`. Scan multiple URLs: `whatweb -i urls.txt`. Pre-installed on Kali Linux.

WhatWeb on Kali Linux

WhatWeb comes pre-installed on Kali Linux. Run `whatweb example.com` to start fingerprinting. Reinstall if needed: `sudo apt install whatweb`. Integrates with [Nmap](/tools/nmap), [Nikto](/tools/nikto), and [Gobuster](/tools/gobuster) for comprehensive web reconnaissance.

WhatWeb output example

Typical output: `http://example.com [200 OK] Apache[2.4.41], PHP[7.4.33], WordPress[5.8.1], jQuery[3.6.0]`. Versions appear in brackets. Color-coded by type (green=CMS, blue=JS, yellow=server). Use `--log-json` for structured output.

WhatWeb plugins

WhatWeb uses 1800+ plugins, each detecting a specific technology. Run `whatweb --list-plugins` to see all available plugins. Use `--use-plugins=WordPress` to focus on specific technology categories for faster, targeted scanning.

WhatWeb GitHub

WhatWeb is hosted at [github.com/urbanadventurer/WhatWeb](https://github.com/urbanadventurer/WhatWeb). Clone with `git clone https://github.com/urbanadventurer/WhatWeb.git`. Open source under GNU GPL v3.

WhatWeb online

There is no official online version. WhatWeb is a command-line tool installed locally. For browser-based detection, use [Wappalyzer](#alternatives) or BuiltWith. Install with `sudo apt install whatweb` on Kali Linux.

WhatWeb scanner

WhatWeb is a fingerprinting scanner, not a vulnerability scanner. It identifies technologies but doesn't test for security flaws. Combine with [Nikto](/tools/nikto), [SQLMap](/tools/sqlmap), or [WPScan](/tools/wpscan) for vulnerability scanning.

Website fingerprinting

Website fingerprinting identifies technologies powering a website — CMS, web server, JavaScript libraries, analytics tools. WhatWeb performs this using 1800+ plugins that analyze HTTP headers, HTML patterns, URL structures, and cookies.

CMS detection with WhatWeb

WhatWeb detects WordPress, Joomla, Drupal, Magento, Shopify, Wix, and hundreds of other CMS platforms through HTML comments, meta tags, URL patterns, cookies, and HTTP headers. Run `whatweb -a 3 example.com` for CMS detection with version numbers.

Technology detection tools

WhatWeb, Wappalyzer, BuiltWith, and Nmap NSE all detect web technologies. WhatWeb stands out for CLI automation, 1800+ plugins, and JSON output. See the [comparison table](#comparison-table) for details.

WhatWeb vs Nikto

WhatWeb fingerprints technologies (what software is running). [Nikto](/tools/nikto) scans for vulnerabilities (what security flaws exist). WhatWeb is faster and generates less traffic. Nikto is more intrusive but finds actual security issues. Use WhatWeb first, then Nikto.

WhatWeb vs Wappalyzer

WhatWeb is CLI for automated bulk scanning with 1800+ plugins and JSON output. Wappalyzer is a browser extension for quick, interactive checks. WhatWeb for automation; Wappalyzer for one-off browser-based checks.

WhatWeb JSON output

Save JSON with `--log-json=filename.json`. Includes target URL, HTTP status, detected technologies with versions, plugin names, detection methods, and HTTP headers. Ideal for automation and programmatic analysis.

WhatWeb legal usage

WhatWeb is legal software. Scanning without permission is illegal under computer fraud laws. Only scan systems you own or have authorization to test. See [ethical hacking fundamentals](/learn/ethical-hacking-fundamentals).

WhatWeb common errors

Common errors: connection timeouts, SSL certificate errors, plugin load errors. If no results, increase aggression with `-a 3`. If blocked by WAF, use `--proxy` and `--wait` for rate limiting. See [WAFW00F](/tools/wafw00f) for WAF detection.

WhatWeb best practices

Start passive, then increase aggression. Save results with `--log-json`. Use `--proxy` for Burp Suite analysis. Add `--wait` for rate limiting. Verify findings manually. Combine with [Nikto](/tools/nikto), [Gobuster](/tools/gobuster), and [WAFW00F](/tools/wafw00f) for comprehensive reconnaissance.

WhatWeb aggression levels

Level 1 (passive): minimal requests, stealthy. Level 2 (mild): better detection. Level 3 (aggressive): version extraction, comprehensive. Level 4 (heavy): maximum probing, lab only. See [scan types](#scan-types).

WhatWeb bulk scanning

Use `-i` flag to scan from text files: `whatweb -i urls.txt`. Add `--log-json=output.json` for JSON output. Use `--threads` for concurrent scanning and `--wait` for rate limiting.

Can WhatWeb detect single-page applications and JavaScript frameworks?

WhatWeb detects JavaScript frameworks like React, Angular, and Vue.js when their signatures appear in the initial HTML response, headers, or bundled asset paths. But because WhatWeb does not execute JavaScript, it can miss technologies that are only loaded client-side after the page renders. For fully client-rendered SPAs, pair WhatWeb with a headless browser or a browser extension, then use [httpx](/tools/httpx) to confirm the server-side stack.

What should I do if WhatWeb is blocked by a WAF?

If a Web Application Firewall blocks or throttles WhatWeb, drop to aggression level 1, add `--wait=3` to slow requests, and rotate the `--user-agent` to a common browser string. Confirm the WAF first with [WAFW00F](/tools/wafw00f), then route traffic through [Burp Suite](/tools/burpsuite) with `--proxy` so you can inspect exactly which request triggered the block.

WhatWeb vs Nmap for web fingerprinting

[Nmap](/tools/nmap) discovers open ports and identifies services at the network level, including web servers via `-sV`. WhatWeb goes deeper on the application layer, identifying CMS platforms, JavaScript libraries, and analytics through 1800+ plugins. Use Nmap to find that ports 80/443 are open, then run WhatWeb to learn exactly what web technology is running.

Why does WhatWeb report the wrong technology or version?

False positives happen when a site shares generic signatures, uses a reverse proxy, or spoofs headers to mislead scanners. Version numbers can also be stale if the server sends a cached or edited banner. Always confirm high-impact findings with verbose mode (`-v`) to see which pattern matched, and cross-check manually before reporting.

How do I run WhatWeb through Burp Suite or a proxy?

Use `--proxy=http://127.0.0.1:8080` to route every WhatWeb request through [Burp Suite](/tools/burpsuite) or ZAP. This lets you log, inspect, and replay the exact traffic WhatWeb sends. Add `--proxy-user=user:pass` if the proxy requires authentication. Combining a proxy with `--wait` is a clean way to keep aggressive scans observable and rate-limited.

Which output format should I use with WhatWeb?

Use `--log-json` for automation and feeding results into other tools — it preserves full plugin metadata. Use `--log-xml` for SIEM and reporting pipelines, `--log-html` for human-readable reports you share with stakeholders, and `--log-sql` when you want to query results in a database. JSON is the best default for most penetration testing workflows.

How do I speed up WhatWeb when scanning many targets?

Increase concurrency with `--threads=20`, keep aggression at level 1 or 2 for the first pass, and feed targets from a file with `-i urls.txt`. Reserve aggression level 3 for a focused second pass on interesting hosts. This two-stage approach fingerprints thousands of URLs quickly, then probes only the ones worth deeper analysis.

Is WhatWeb still maintained and safe to rely on?

Yes. WhatWeb is open source under GPL v3, hosted at github.com/urbanadventurer/WhatWeb, and ships pre-installed on current Kali Linux releases. Its plugin database continues to receive community contributions. For the newest technology signatures you can also clone the latest version from GitHub instead of relying only on the packaged release.

Output Explanation

WhatWeb output displays each detected technology on a single line with the target URL, HTTP status code, and detected technologies. Example outputs:

  Apache: http://example.com [200 OK] Apache[2.4.52]
  Nginx: http://example.com [200 OK] Nginx[1.18.0]
  WordPress: http://example.com [200 OK] WordPress[6.1.1], jQuery[3.6.0], PHP[8.1.2]
  Cloudflare: http://example.com [200 OK] Cloudflare[DDoS protection], PHP[7.4.33]
  React: http://example.com [200 OK] React[18.2.0], Webpack[Bundler]
  PHP: http://example.com [200 OK] PHP[8.1.2], X-Powered-By[PHP/8.1.2]

The default color-coded output differentiates technology types: green for CMS, blue for JavaScript libraries, yellow for web servers, and red for embedded devices. Verbose mode (-v) reveals the specific HTTP headers, HTML patterns, or URL structures that triggered each detection. JSON output (--log-json) provides structured data with full plugin details, HTTP response headers, and detection methods.

Ethical Usage Notice

This tool is designed for authorized security testing, educational purposes, and legitimate network administration only. Unauthorized access to computer systems is illegal.

WhatWeb

Installation

Basic Syntax

Quick Facts

Tool Overview

Common Commands

Step-by-Step Guide

Warnings

Use Cases

CMS Detection

Web Server Identification

JavaScript Library Detection

Analytics Detection

Version Fingerprinting

Technology Inventory

Key Features

Comparison

WhatWeb vs httpx vs Wappalyzer — Feature Depth

WhatWeb Aggression Levels — Speed vs Detail

WhatWeb vs Nmap NSE — Web Recon Overlap

Output Formats — When to Use Which

Best Practices

Common Errors

People Also Ask

Learning Path

Related Tools

Nikto

Nmap

Gobuster

WPScan

Burp Suite

WAFW00F

Subfinder

Amass

Frequently Asked Questions

Tags

Output Explanation

Ethical Usage Notice