DEV Community: OpenCV

Holehe Alternative in 2026: Modern OSINT Email & Username Intelligence with user-scanner

OpenCV — Thu, 13 Aug 2026 18:21:49 +0000

When mapping digital footprints, security analysts and open-source intelligence (OSINT) practitioners rely heavily on registration checkers. For years, single-purpose utilities like Holehe were the industry standard for checking email recovery endpoints. However, modern target profiling requires deeper correlation, higher concurrency, and cross-platform pivoting across both emails and usernames.

Enter user-scanner—a high-throughput, 2-in-1 Python OSINT engine designed for deep email registration checking, username profiling, and cross-scan intelligence.

Technical Comparison: `user-scanner` vs. Legacy OSINT Tools

Feature / Capability	Holehe	Sherlock / Maigret	`user-scanner`
Primary Input Vectors	Email Only	Username Only	2-in-1 (380+ Combined Vectors)
Target Integration	~120 Email Sites	Scrapes Web Forms	155+ Email & 225+ Username Sites
Pivoting / Cross-Scanning	❌ No	❌ No	✅ Auto-Pivots (Email ↔ Username ↔ Links)
Breach Intelligence	❌ No	❌ No	✅ Hudson Rock Infostealer API (`--hudson`)
Engine Core	Basic Async	Basic Requests	`httpx` + `curl_cffi` (TLS Impersonation)
Reporting Formats	CLI / JSON	CLI / CSV / HTML	PDF (with Media/Avatars), JSON, CSV
Deployment / Ecosystem	Pip	Pip	Pip, Virtual Env, Nix (`nix run`)

Core Capabilities of `user-scanner`

1. Cross-Scan & Pivot Intelligence Engine

Unlike legacy checkers that stop after returning a boolean hit, user-scanner features an automated cross-scanning engine (--cross-scan). It mines exposed handles, profile links, and secondary email addresses from initial scan metadata and recursively pivots across secondary target vectors.

-e → Username: Extracts handles or social links exposed on an email's registered profile.
-u → Email: Extracts public email addresses published on target profile pages.
Multi-Depth Chains: Supports configurable chain depth (--cross-depth) and link validation rules (--cross-links verified).

2. Infostealer Breach Intelligence (`--hudson`)

Integrates directly with Hudson Rock's infostealer malware infection logs. Running --hudson alongside an email or username scan instantly correlates targets against compromise logs and malware-exfiltrated credentials.

3. High-Throughput Request Engine & Anti-Blocking

Built on top of httpx and curl_cffi, user-scanner utilizes automated TLS fingerprint impersonation to defeat basic web application firewalls (WAFs) and rate-limiting. It includes built-in proxy rotation with protocol auto-detection (http, socks5) and health validation (--validate-proxies).

Quickstart Usage Examples

Single & Cross-Scan Pivot Execution

# Basic email scan
user-scanner -e target@domain.com

# Deep pivot scan: extract handles & secondary emails up to 2 hops deep
user-scanner -e target@domain.com --cross-scan --cross-depth 2

# Username scan with Infostealer Malware Breach check
user-scanner -u targetuser --hudson

High-Concurrency Output & Reporting

# Execute with custom concurrency and generate a visual PDF report
user-scanner -u targetuser -C 100 -f pdf -o report.pdf

# Rotate proxies with pre-scan health validation
user-scanner -u targetuser -P proxies.txt --validate-proxies

Direct Python Integration (Library Mode)

import asyncio
from user_scanner.core import engine
from user_scanner.email_scan.shopping import etsy

async def main():
    result = await engine.check(etsy, "target@gmail.com")
    print(result.to_json())

asyncio.run(main())

Conclusion

For OSINT researchers looking for an active, modern, and extensible successor to Holehe, user-scanner offers a comprehensive solution. By pairing email enumeration with username profiling, TLS fingerprinting, infostealer intel, and recursive cross-scanning, it streamlines digital footprinting into a single CLI tool.

The Undisputed King 👑 of 2026 OSINT: Why User Scanner is the Only Recon Tool You Need

OpenCV — Mon, 06 Jul 2026 07:07:02 +0000

If you’ve spent any time in the trenches of Open Source Intelligence (OSINT) recently, you know the absolute pain of modern identity reconnaissance.

The "Old Guard" of free CLI tools is dying. They are plagued by unmaintained modules, rate-limit traps, and Cloudflare walls. But worse than all of that? They lie to you. They hit a custom 404 page, get confused by the HTML, and confidently print: [+] Account Found! sending you down a three-hour rabbit hole chasing a ghost.

In this game, the worst data isn't missing data. It's fake data.

Enter user-scanner by kaifcodec.

It has quietly (and now, very loudly) taken the throne as the undisputed king of free, terminal-based identity mapping in 2026. It is the loyal dark knight of OSINT: it will stand in the war zone all day, take the hits, and if it fails, it will look you in the eye and say "I failed." But it will never give you a false positive.

Here is why user-scanner is blowing everything else out of the water right now.

1. The 2-in-1 Engine That Actually Works

Until now, you had to maintain a fragmented mess of Python scripts—one for emails, one for usernames, and a browser open for breach data.

user-scanner bridges the gap. It supports 295+ scan vectors (110+ email-integrated sites and 185+ username platforms). You can run targeted email checks, massive username sweeps, or simultaneous dual-identifier scans from a single command line.

user-scanner -e johndoe@gmail.com   # Scan email footprint
user-scanner -u johndoe             # Map username presence

2. Deep Profile Extraction (No More "Dumb Requests")

Lazy tools just do a basic HTTP request and look for a 200 status code. user-scanner acts like a scalpel. It actively targets signup-attempt endpoints, custom mobile APIs, and parses the actual JSON responses.

When it gets a hit, it doesn't just say "Found." It extracts the metadata. Look at what happens when you hit a target's Etsy account using its library mode:

{
  "email": "test@gmail.com",
  "category": "Shopping",
  "site_name": "Etsy",
  "status": "Registered",
  "extra": {
    "id": 98832,
    "name": "test123",
    "has_public_page": "No",
    "joined": "2010-09-19 05:04:06",
    "last_profile_update": "2020-07-31 01:40:24",
    "avatar": "[https://i.etsystatic.com/.../default_avatar.png](https://i.etsystatic.com/.../default_avatar.png)"
  }
}

Creation dates. Follower counts. Privacy settings. Avatar URLs. It provides the cryptographic proof that the account exists, completely neutralizing the risk of a false positive.

3. Zero-Cost Infostealer Intelligence Fusion

This is where it goes from a "good tool" to an "enterprise-grade weapon."

By passing the --hudson flag, user-scanner directly integrates with Hudson Rock threat intelligence. In a fraction of a second, it checks if your target's username or email has been exposed in active infostealer malware logs (like Lumma or RedLine).

Getting automated, command-line cross-referencing for infostealer logs without paying thousands of dollars for corporate API keys is frankly absurd.

4. Built for the Trenches: Nix, Proxies, and OPSEC

The architecture of this tool is a masterclass in modern security development:

Pre-Scan Proxy Validation: If you pass it a proxy list, it doesn't just blindly pipe them in. It uses --validate-proxies to forcefully health-check every proxy against a live target first. Dead proxies are dropped before the scan starts, ensuring connection timeouts aren't misread as "Account Not Found."
Nix Shell Support: For the paranoid analyst, you don't even need to pollute your local environment. Run nix run github:kaifcodec/user-scanner/main and fire off a scan in a completely sandboxed, disposable container.
Brutal Honesty: If an API changes overnight or your IP gets geoblocked, it throws a clean 403 Forbidden error. It forces you to fix your network state rather than guessing the result.

The Verdict

We are living in an era where data is heavily guarded and APIs are being locked down. Tools that rely on bloated spreadsheets of 1,000+ broken sites are dead weight.

If you are an investigator, a red teamer, or just an OSINT enthusiast who values brutal accuracy over ego, user-scanner is the only tool you need in your PATH right now. It doesn't hype up its results. It just monitors the line, extracts the truth, and fails gracefully when the walls are too high.

Check it out, star the repo, and stop letting bad tools ruin your investigations.

GitHub Repo: http://github.com/kaifcodec/user-scanner
PyPI: pip install user-scanner

RIP Holehe: Why User-Scanner is the New King of Email OSINT 👑

OpenCV — Sat, 21 Feb 2026 15:47:07 +0000

Why Holehe is Dead and Why You Should Switch to User-Scanner 🔍

If you’ve been in the OSINT space for a while, you know Holehe. It was the gold standard for email lookups. But let’s be real: Holehe hasn't seen a major update in years, many of its modules are broken, and it frequently hits rate limits or returns false positives.

In 2026, it’s time to move on. Enter user-scanner—the modern, lightweight, and actively maintained successor that does everything Holehe did, but better.

🛠️ Key Features of User-Scanner

User-Scanner isn't just a replacement; it’s an upgrade. It combines the best of Holehe (email scanning) and Sherlock (username scanning) into one streamlined tool.

2-in-1 Dual Scanning: Check email registrations and username availability in a single command.
Smart Permutations: Automatically generates "wildcard" variations of usernames (e.g., adding suffixes) to find hidden or secondary accounts.
Active Module Updates: Unlike Holehe, User-Scanner is actively maintained to fix modules as soon as platforms change their login or registration flows.
Advanced Proxy Support: Includes a built-in --validate-proxies flag to filter out dead proxies before you start your scan.
Clean Exporting: Native support for JSON and CSV formats, making it easy to pipe data into other tools or reports.
Developer Library Mode: You can import it directly into your Python projects using user_scanner.core.

🚀 Quick Start

Getting started is faster than setting up a virtual environment (though you should still use one!).

1. Installation

pip install user-scanner

2. The "Better Than Holehe" Scan

Replace your old Holehe workflow with this:

user-scanner -e "target_email@gmail.com" -v

3. Bulk Scanning (A Feature Holehe Lacked)

Have a list of 100 emails? No problem:

user-scanner -ef emails.txt -o results.json

Library mode for email_scan

Only available for user-scanner>=1.2.0

See full usage (eg. category checks, full scan) guide library usage

Email scan example (single module):


import asyncio
from user_scanner.core import engine
from user_scanner.email_scan.dev import github

async def main():
    # Engine detects 'email_scan' path -> returns "Registered" status
    result = await engine.check(github, "test@gmail.com")
    json_data = result.to_json() # returns JSON output
    csv_data = result.to_csv()   # returns CSV output
    print(json_data)             # prints the json data

asyncio.run(main())

Output:


{
        "email": "test@gmail.com",
        "category": "Dev",
        "site_name": "Github",
        "status": "Registered",
        "url": "https://github.com",
        "reason": ""
}

💀 Why "Holehe" is Dead

Holehe relied on specific password-reset and registration endpoints that many platforms (like X/Twitter and Instagram) have since hardened or changed. Without active maintenance, a tool like Holehe becomes a "false negative" machine.

User-Scanner uses updated logic, better error handling and modern libraries like httpx to handle these requests more reliably and faster than the older requests or trio based implementations.

🛡️ Use Responsibly

This tool is built for authorized security research, bug bounty hunting, and digital footprint audits. Always ensure your investigations comply with local laws and the Terms of Service of the platforms being scanned.

📈 Conclusion

If your OSINT toolkit still relies on Holehe, you're likely missing half the picture. Switch to User-Scanner for more accurate data and a much better developer experience.

Check it out on GitHub: kaifcodec/user-scanner

Are you still holding onto legacy tools, or have you made the switch? Let's talk in the comments!