Introduction

Welcome to Quantium - the premium software ecosystem built for professionals.

What is Quantium?

Quantium is a comprehensive suite of high-performance tools designed for experts in cybersecurity, data processing, and digital forensics. Every Quantium tool is built from scratch for maximum performance and reliability.

Why Choose Quantium?

Performance

High thread capacity
Process large files with streaming
Efficient RAM usage
Custom implementations

Built for Professionals

Hardware-locked licenses for security
Memory wiping for sensitive data
Professional code protection against reverse engineering

Development

Continuous updates based on user feedback
Built from real-world needs

Support

24/7 human support on Telegram

Who Uses Quantium?

Professional-Grade Tools for Professional Users

Our tools are designed for:

Cybersecurity professionals conducting research and analysis
Digital forensics experts processing large datasets
Penetration testers requiring reliable, fast tools
Data analysts handling massive credential databases
Security researchers needing reliable tools

The Quantium Ecosystem

Specialized Tools for Every Professional Need

Our suite includes:

Chronos - Advanced URL:LOG:PASS processor with 10 specialized modules
Vanadum - Next-gen TLS API with browser fingerprinting and anti-detection
Rapid - High-performance email checker with 15M+ server database and mail viewer

Getting Started

Ready to experience the difference?

Start with:

System Requirements - Ensure your system meets our specifications
Installation Guide - Get Quantium running on your machine
Quick Start - Begin using our tools in minutes
Best Practices - Learn from professional workflows

Support & Community

24/7 Support: Direct access to our team on Telegram
Regular Updates: Continuous improvements and new features
Professional Network: Join experts using Quantium worldwide

Quantium - Software for Professionals

quantium.rs | Support

System Requirements

Ready to get started? Download Quantium from quantium.rs

Operating System

Windows 10 (version 1903 or later)
Windows 11
Windows Server (2019 or later)

Required Dependencies

WebView2 Runtime

Quantium applications use WebView2 for the user interface. Download and install the Evergreen Bootstrapper from:

Microsoft Edge WebView2

Visual C++ Redistributable

Required for native Windows components:

Download x64 version (64-bit systems)
Download x86 version (32-bit systems)

Hardware Requirements

CPU: Multi-core processor (more cores = better performance)
RAM: Depends on your workload and file sizes
Storage: SSD recommended for optimal performance
Network: Internet connection required for authentication and downloads

Performance Considerations

File Processing

Large file processing requires adequate free disk space
SSD storage significantly improves processing speed
RAM requirements scale with file size and concurrent operations

Multi-threading

Thread count scales with CPU cores
RAM usage increases with thread count

Installation Order

Install WebView2 Runtime
Install Visual C++ Redistributable

Both dependencies must be installed before running Quantium software.

Compatibility Notes

64-bit Windows only
Windows Defender may flag the software - this is a false positive
HWID can be changed once every 24 hours if needed
Important: Windows time must be synchronized for authentication to work correctly

Download Quantium: quantium.rs Need Help?: quantium.rs/support

Quick Start

This guide helps you get started with Quantium tools quickly.

Choose Your Tool

Credential Processing

Chronos - Complete toolkit for url:log:pass processing with 10 modules for cleaning, sorting, deduplication, and extraction

Email Tools

Rapid - High-performance email checker with IMAP and Outlook/Hotmail support, built-in mail viewer, and 15M+ server database

Network & API Tools

Vanadum - Next-gen TLS API with browser fingerprinting and anti-detection for network applications

Getting Started

Get Quantium: Download from quantium.rs
Launch: Run the Quantium launcher
Install: Choose and install your desired tool
Configure: Set up your preferences
Process: Start working with your data

Support

Need help? We’re here for you:

Website: quantium.rs
Support: quantium.rs/support
Telegram: 24/7 direct support

Launcher

The central hub for managing and launching all Quantium tools.

Overview

Quantium Launcher is your gateway to the entire Quantium ecosystem. It handles tool installation, updates, license validation, and provides one-click access to all your licensed tools.

Key Features

Tool Management: Install, update, and uninstall tools
Automatic Updates: Keep all tools up-to-date automatically
License Validation: Secure authentication and subscription management
One-Click Launch: Start any tool instantly
Progress Tracking: Real-time download and installation progress
Version Control: View current and available versions

Interface Overview

Main Dashboard

The launcher displays all available tools in your subscription:

Tool name and icon
Current version installed
Update available indicator
Install/Launch button

Tool Cards

Each tool card shows:

Status: Installed, Update Available, or Not Installed
Version: Currently installed version
Size: Disk space required
Description: Brief tool overview

How It Works

Login: Authenticate with your Quantium account
Browse Tools: View all available tools in your subscription
Install: One-click installation of any tool
Launch: Tools update automatically before starting
Manage: Uninstall tools to free up space

Tool Management

Installing Tools

Click on any tool card
Click “Install” button
Wait for download and installation
Tool is ready to launch

Updating Tools

Updates are handled automatically:

Click on an installed tool
If update available, it downloads automatically
Tool launches after update completes

Uninstalling Tools

Right-click on installed tool
Select “Uninstall”
Confirm removal
Disk space is freed

Getting Started

Download the launcher from your account dashboard at quantium.rs
Install and run the launcher
Login with your credentials
Start installing and using tools

Troubleshooting

Verify credentials are correct
Check internet connection
Clear launcher cache
Contact support if issue persists

Download fails

Check disk space
Verify internet connection
Try again later
Check firewall settings

Tool won’t launch

Ensure tool is fully installed
Check for pending updates
Verify license is active
Restart launcher

Slow downloads

Check internet connection speed
Pause and resume download
Try different time (server load varies)

FAQ

Can I install tools on external drive?

Currently, tools install to the default location. External drive support may be added in future updates.

How much disk space do I need?

Depends on which tools you install. Each tool shows its size on the install screen.

Do I need to be online?

Internet connection is required for:

License validation
Downloads and updates
Tool launches (for license check)

Can I use multiple accounts?

Each launcher installation is tied to one account. Contact support for multi-user setups.

How do I transfer to a new computer?

Install launcher on new computer
Login with your credentials
Contact support if hardware lock issue occurs

Chronos

Complete toolkit for url:log:pass and log:pass processing — clean, sort, dedupe massive credential files effortlessly.

Overview

Chronos is a high-performance data processing suite designed for handling large-scale text and archive files. With 10 specialized modules, it provides comprehensive tools for cleaning, sorting, extracting, and organizing credential data.

Key Features

Multi-format Support: Process ZIP, RAR, 7Z archives with password protection
Parallel Processing: Utilize all CPU cores for maximum performance
Memory Efficient: Stream processing for handling terabyte-sized files
Pattern Matching: Advanced regex support for complex data extraction
Real-time Progress: Monitor processing status and results

Available Modules

Credential Processing

ULP Sorter - Categorize credentials by type (email, phone, username)
ULP Cleaner - Validate and clean URL:login:pass format
ULP Extractor - Extract passwords from stealer logs and archives
LP Cleaner - Advanced validation for login:pass format
CIS Cleaner - Filter lines based on blacklist patterns

File Operations

Splitter - Split large files into chunks
Joiner - Merge multiple files
Deduper - Remove duplicate lines
Filter - Regex-based line filtering

Database Tools

Anti-Public - Find unique credentials not in your database

Quick Start

Launch Chronos from the Quantium launcher
Select your desired module from the dropdown
Configure input files and options
Click Execute to start processing

Performance

Built for Speed and Scale

Handles large files through streaming
Minimal memory footprint
Multi-threading support

Use Cases

Clean and organize credential databases
Extract specific data patterns from logs
Remove duplicates from massive datasets
Split large files for easier handling
Filter data based on complex criteria

Chronos Modules

ULP Sorter

Smart Categorization Engine
Sorts url:log:pass files by credential type and pattern

Features

Automatic categorization: MailPass, UserPass, PhonePass, UrlLogPass, LogPass
Pattern-based filtering with regex support
Separate output files for each category
Optional deduplication within sorted files
Fast Search: Performance improvement (premium feature)

Common Use Cases

Separate email credentials from usernames
Extract phone number logins
Filter by specific patterns within categories
Organize mixed-format credential dumps

ULP Extractor

Archive Mining Tool
Extracts credentials from password files and archives

Features

Searches for password files (passw*.txt patterns)
Recursive archive extraction (ZIP, RAR, 7Z)
Path filtering with mask patterns
Regex filtering for specific content

Common Use Cases

Process stealer log archives
Extract credentials from nested archives
Filter by specific file paths or patterns
Consolidate passwords from multiple sources

ULP Cleaner

Data Validation & Cleaning
Validates and cleans url:log:pass formatted data

Features

Validates credential format using parser
Removes protocols and cleans URLs
Separates into “normal” and “bad” outputs
Filters spam/ads patterns

Common Use Cases

Clean raw credential dumps
Remove invalid/corrupted entries
Prepare data for further processing
Validate URL:login:password format

CIS Cleaner

Blacklist-based Filtering Filters lines based on configurable blacklist patterns

Features

Blacklist pattern matching
Fast regex-based processing
Separate outputs for cleaned and blacklisted lines

Common Use Cases

Remove unwanted entries based on patterns
Filter data using blacklist rules
Clean databases by removing matched content

LP Cleaner

Advanced Validation Engine
Advanced cleaner for log:pass format

Features

Login/password length validation (min/max)
Password complexity requirements (uppercase, lowercase, digits, special chars)
Email format validation (optional)
Separates valid and invalid entries

Common Use Cases

Filter by password strength
Validate email:password lists
Enforce password policy requirements
Clean data for specific services

Anti-Public

Find Unique Credentials
Compares against your stored database to find new entries

Features

Identify credentials not in your existing collection
Fast in-memory comparison
Low-memory mode using hashes
Optional update of stored database

Common Use Cases

Find new unique credentials
Compare against previous collections
Build a master database over time
Differential analysis between datasets

Joiner

File Consolidation Tool
Merges multiple files into one

Features

Combine split files
Merge different sources
Optional deduplication
Format preservation

Common Use Cases

Reassemble split files
Combine multiple databases
Consolidate results

Deduper

Duplicate Line Removal
Efficiently removes duplicate lines from text files

Features

Fast deduplication algorithm
Memory-efficient processing
Preserves original order
Handles large files with ease

Common Use Cases

Remove duplicate credentials
Clean repetitive data
Optimize file size
Ensure unique entries only

Splitter

File Division Tool
Splits large files into manageable chunks

Features

Configurable chunk size
Line-based splitting (no data corruption)
Sequential naming
Progress tracking

Common Use Cases

Break down TB-sized files
Prepare data for parallel processing
Create manageable file sizes

Filter

Advanced Pattern Matching
Advanced filtering using regular expressions

Features

Complex regex pattern support
Include/exclude modes (invert filter)

Common Use Cases

Extract specific patterns
Remove unwanted data
Complex data filtering
Custom search operations

Configuration

Global Settings

Output Directory

Default: %AppData%/quantium-v5/chronos/output (Windows)
Each run creates a timestamped subdirectory
Custom location can be set in the application

Thread Count

Default: Automatically detects CPU cores
Currently used for parallel archive extraction in ULP Extractor
Controls Rayon thread pool size

Buffer Size

Default: 10,000,000 lines
Controls when data is flushed to disk
Prevents excessive memory usage during processing

Module-Specific Settings

Archive Processing

Password List: Text file with one password per line

Deduplication

Fast Mode: Quick hash-based comparison
Compressed Mode: Slower but more thorough

Supported Formats

Credential Formats

Chronos processes credentials in various formats. See Common Data Formats for standard formats.

Additional Chronos Formats:

Log:Pass:URL - user123:pass456:https://example.com

Output Formats:

UrlLogPass: URL:LOGIN:PASSWORD
LogPassUrl: LOGIN:PASSWORD:URL
LogPass: LOGIN:PASSWORD

Normal: Multi-line format

Host: URL
Login: LOGIN
Password: PASSWORD

File Types

Text files (.txt)
Archives (.zip, .rar, .7z) with password support
Mixed format directories

Format Requirements

Minimum 3 characters per field
Valid URL format required for URL fields
UTF-8 encoding supported

Performance Tips

Storage

Speed is Everything!

SSD strongly recommended for optimal performance
Use CrystalDiskMark to verify disk speed
Fast I/O is critical for processing large files

Memory

Buffer automatically flushes at configured line count
Monitor RAM usage with large datasets

FAQ

General Questions

Which module should I use?

ULP Cleaner: Validate and clean url:log:pass data
ULP Sorter: Categorize credentials by type (email, phone, username)
ULP Extractor: Extract credentials from archives and password files
LP Cleaner: Validate login:pass format with complexity rules
CIS Cleaner: Filter lines based on blacklist patterns
Anti-Public: Find unique credentials not in your database
Splitter: Break large files into chunks
Joiner: Merge multiple files
Deduper: Remove duplicate lines
Filter: Regex-based filtering

What’s the difference between ULP Cleaner and LP Cleaner?

ULP Cleaner: Handles url:log:pass format, validates URL structure
LP Cleaner: Handles log:pass format, focuses on password validation

Can I process multiple files at once?

Yes, most modules support:

Multiple input files
Directory scanning
Archive processing (ZIP, RAR, 7Z)

What file formats are supported?

Input formats:

Text files (.txt)
CSV files (.csv)
Archives (.zip, .rar, .7z) - including password-protected
Any plain text format

Performance

How do I optimize processing speed?

Use SSD: Disk I/O is often the bottleneck
Close other apps: Free up RAM and CPU
Process in chunks: Split very large files first
Enable Fast Search: Premium feature for faster ULP Sorter

How much RAM do I need?

Chronos uses streaming processing, so RAM requirements are minimal for most operations. Anti-Public mode loads the database to memory, so larger RAM helps. Low-memory mode is available for systems with limited RAM.

Can Chronos handle large files?

Yes! Streaming processing allows handling large files:

Minimal memory footprint
Only limited by storage space

Why is processing slow?

Common causes:

HDD instead of SSD: Major bottleneck for large files
Complex regex patterns: Simplify if possible
Archive extraction: Nested archives take longer
Antivirus scanning: May slow file operations

Modules

ULP Cleaner

What does “remove protocols” do?

Strips http://, https://, ftp:// from URLs, leaving clean domain:path format.

What are “spam/ads patterns”?

Pre-defined patterns for removing common advertising and spam URLs that pollute credential databases.

Why are credentials going to “bad” output?

Credentials are marked bad if:

URL format is invalid
Login or password is empty
Line doesn’t match url:log:pass format

ULP Sorter

How does automatic categorization work?

Analyzes login field format:

MailPass: email@domain format
UserPass: username format
PhonePass: phone number patterns
UrlLogPass: original format
LogPass: stripped URL format

What is “Fast Search”?

Premium feature that uses optimized algorithms for faster pattern matching.

ULP Extractor

What files does it search for?

Default pattern: passw*.txt (passwords.txt, password.txt, etc.)

How deep does archive extraction go?

Recursive extraction up to 3 levels:

Archive → Archive → Archive → Files

Can I extract from password-protected archives?

Yes, provide the password in settings. Common passwords are tried automatically.

CIS Cleaner

What does CIS Cleaner do?

Filters lines based on blacklist patterns. Creates two outputs:

Cleaned: Lines that don’t match blacklist
Blacklisted: Lines that were removed

When should I use it?

Use CIS Cleaner to remove unwanted entries from your data based on pattern matching.

Anti-Public

What is “low-memory mode”?

Uses hashed comparisons instead of loading full database to memory. Slower but works on systems with limited RAM.

Can I update my database automatically?

Yes, enable “Update stored database” to add new unique findings to your reference database.

Why is Anti-Public slow?

Anti-Public needs to compare every line against your database:

Large databases require more memory
Use low-memory mode for systems with limited RAM
SSD significantly improves performance

LP Cleaner

What complexity options are available?

Min/Max length: Password length requirements
Uppercase/Lowercase: Required character types
Digits: Must contain numbers
Special characters: Must contain symbols

Should I use email validation?

Enable if you want only email:password format. Disable if usernames or other login types are acceptable.

Filter

What regex syntax is supported?

Full Rust regex syntax:

.* - any characters
\d+ - digits
[a-z] - character classes
^ and $ - anchors

What does “invert filter” do?

Keeps lines that DON’T match the pattern instead of those that do.

Output

Where are results saved?

Default: chronos_output/ in your working directory

Each module creates appropriate subfolders
Timestamps identify processing runs

Can I customize output location?

Yes, specify custom output directory in module settings.

Troubleshooting

“Invalid UTF-8” errors

Your input file has encoding issues:

Convert to UTF-8 using a text editor
Use encoding detection tools
Remove problematic lines

Processing hangs

Check disk space
Verify file isn’t locked by another process
Try smaller test file first
Check for infinite archive loops

Results are empty

Verify input file format
Check filter/pattern settings
Review module configuration
Test with sample data

Archive extraction fails

Check archive isn’t corrupted
Provide correct password
Ensure enough disk space for extraction
Update archive tools if needed

Best Practices

Workflow recommendations

ULP Extractor → Extract from archives first
ULP Cleaner → Validate and clean extracted data
Deduper → Remove duplicates
ULP Sorter → Categorize by type
Anti-Public → Find unique entries

Handling very large files

Use Splitter to break into manageable chunks
Process chunks in parallel with multiple instances
Use Joiner to combine results
Use Deduper on final combined output

Preserving data integrity

Always keep original files
Process copies, not originals
Verify output counts match expectations
Use checksums for critical data

Seedx

Advanced seed-phrase parser that surfaces hidden insights from huge datasets — even in complex formats.

Overview

Seedx is a high-performance tool for extracting cryptocurrency seed phrases and private keys from various file formats. It can scan entire directories, process archives, and extract text from images using built-in OCR.

Key Features

Multi-format Support: Text, PDF, Word, Excel, images, and archives
Smart Detection: Typo correction and pattern recognition
Archive Processing: Recursive extraction up to 3 levels deep
AI Image Analysis: Extract seed phrases from screenshots and photos
Parallel Processing: Multi-threaded scanning for speed

What Seedx Finds

Seed Phrases

BIP39 mnemonic phrases (12, 15, 18, 21, or 24 words)
Multiple language support for international seed phrases
Smart typo correction for misspelled words

Private Keys

Seedx supports private key detection from all major blockchains:

Bitcoin (BTC) and forks: BCH, BSV, BTG
Ethereum (ETH) and EVM chains: BSC, Polygon, Arbitrum, Avalanche, Fantom
Altcoins: Litecoin, Dogecoin, Dash, Solana, VeChain
Key Formats:
- Hexadecimal (raw and 0x-prefixed)
- WIF (Wallet Import Format) - compressed & uncompressed
- Extended keys (xprv, yprv, zprv)
- Solana base58 and byte arrays
Validation: Cryptographic verification for 93%+ detection accuracy

Other Secrets

API keys from various services
Authentication tokens and session keys
Access credentials and sensitive data

Quick Start

Launch Seedx from the Quantium launcher
Select source directory to scan
Configure detection options
Start scanning

Output

Seedx creates organized output files for easy processing:

output_dir/
├── seeds.txt              # Found seed phrases
├── private_keys.txt       # Cryptocurrency keys
├── other_secrets.txt      # API keys & tokens
└── csv/
    ├── seeds.csv          # CSV with source locations
    ├── private_keys.csv
    └── other_secrets.csv

Pro Tip: CSV files include source file paths for tracking where each item was found!

Features

File Format Support

Documents

Text: txt, md, log, dat
PDF: All PDF versions
Microsoft Office: doc, docx, xls, xlsx, ppt, pptx
Web: html, htm, xml, json
Other: rtf, csv, tsv

Images

Formats: jpg, jpeg, png, gif
AI Analysis: Extract text from images using built-in OCR
Use Cases: Screenshots, photos of written seeds

Detection Methods

Seed Phrase Detection

Pattern matching for word sequences
BIP39 wordlist validation
Length validation (12, 15, 18, 21, 24 words)
Typo Correction: Fixes misspelled BIP39 words
Homoglyph Detection: Handles similar-looking characters
List Recognition: Detects numbered/bulleted lists
Multi-language: Supports all BIP39 languages

Private Key Detection

Seedx detects and validates private keys from all major blockchains:

Supported Blockchains:

Bitcoin & Forks: BTC, BCH, BSV, BTG
EVM Chains: Ethereum, BSC/BNB, Polygon/MATIC, Arbitrum, Avalanche, Fantom, Moonriver, HECO
Other Chains: Litecoin, Dogecoin, Dash, Solana, VeChain

Key Formats:

Hexadecimal: Raw 64-char hex, 0x-prefixed (Ethereum style)
WIF (Wallet Import Format): Compressed (52 chars) and uncompressed (51 chars)
Extended Keys: xprv, yprv, zprv (BIP32 hierarchical deterministic)
Solana: Base58 encoded (88-96 chars) and byte array format
Validation: Cryptographic validation using secp256k1/ed25519
Detection Rate: 93%+ accuracy with zero false positives

AI Detection

Sends images to built-in OCR for text extraction
Processes OCR responses to find seed phrases
Included with subscription

Performance Features

Multi-threading

Parallel file processing
Configurable thread count
Efficient queue management

Memory Optimization

Streaming file reading
Duplicate detection filter
Batch writing to disk

Archive Handling

Extracts to memory when possible
Temporary file cleanup
Recursive processing

Output Organization

File Types

Text Files: Just the secrets, one per line
CSV Files: Secrets with source file paths

Deduplication

Prevents duplicate entries
Tracks unique secrets only
Case-insensitive for certain types

Real-time Updates

Progress counter
Files processed counter
Secrets found counter

Configuration

Basic Settings

Source Directory

Select folder to scan
Supports recursive scanning
Can process single files

Output

Auto-generated directory with timestamp
Separate files for each secret type

Thread Count

Default: Number of CPU cores
Controls parallel file processing
Higher = faster (with more RAM usage)

Detection Options

Secret Types

Choose what to search for:

Seed Phrases: BIP39 mnemonics
Private Keys: Crypto private keys
Other Secrets: API keys, tokens

Enhanced Detection

Advanced features for better results:

Typo Correction: Fix misspelled words
Custom Words: Detect non-standard words
Electrum Format: Support Electrum seeds
Edit Distance: Maximum typos to correct (default: 2)
Bruteforce: Attempt word variations
Word Similarity: Threshold for matching (0.0-1.0)

Archive Settings

Process Archives: Extract and scan archives
Recursive Archives: Scan nested archives
Max Depth: How deep to go (default: 3)

AI Settings

OCR Configuration

Enable AI Mode: Toggle image processing
Uses built-in OCR service
Included with subscription
Processes images sequentially

Performance Tips

Large Directories

Start with lower thread count
Monitor RAM usage
Use SSD for better speed

Many Small Files

Increase thread count
Enable archive processing
Check buffer size

Image Processing

AI mode slows scanning (sequential processing)
Only enable for necessary images

AI Integration

Overview

Seedx uses built-in OCR to extract seed phrases from images - useful for screenshots, photos of written seeds, or any image containing text.

Setup

Requirements

Seedx subscription (OCR included)
Internet connection
Supported image formats: JPG, PNG, GIF

Configuration

Enable AI mode in settings
OCR is automatically configured

How It Works

Image Detection: Seedx identifies image files during scanning
OCR Request: Sends image to built-in OCR service
Response Processing: Parses OCR response for seed phrases
Validation: Validates extracted words against BIP39 wordlist

Use Cases

Extract seeds from screenshots
Process photos of paper wallets
Recover seeds from damaged documents
Handle non-standard text formats

Limitations

Processing is sequential (one image at a time)
Internet connection needed
Image quality affects accuracy

Privacy Note

Images are processed through Quantium’s OCR service. All processing is handled securely through our infrastructure.

FAQ

General Questions

What can Seedx find?

Seedx extracts:

Seed phrases: BIP39 mnemonics (12, 15, 18, 21, 24 words)
Private keys: Cryptocurrency keys in various formats
API keys: From various services
Tokens: Authentication and session tokens

What file formats are supported?

Text formats:

Plain text (.txt)
PDF documents (.pdf)
Word documents (.docx)
Excel spreadsheets (.xlsx)
Archives (.zip, .rar, .7z)

Image formats (with AI):

PNG, JPG, JPEG, GIF
Screenshots and photos

Do I need an API key for AI features?

No, OCR is built-in and included with your subscription. Just enable AI mode in settings.

How does typo correction work?

Seedx uses intelligent matching to correct common seed phrase typos:

Misspelled BIP39 words
Character substitutions
Missing or extra letters

AI Integration

Which AI providers are supported?

Seedx uses Quantium’s built-in OCR API for image processing. No external API keys needed - it’s included with your subscription.

How accurate is AI image extraction?

Very accurate for clear images. Factors affecting accuracy:

Image quality and resolution
Text clarity and contrast
Background noise/clutter
Handwritten vs typed text

Are there any limits on AI processing?

OCR requests are processed sequentially to prevent API overload.

How much does AI processing cost?

OCR is included with your Seedx subscription - no additional costs.

Can Seedx read handwritten seed phrases?

Yes, with AI integration. Accuracy depends on handwriting legibility.

Performance

How fast is Seedx?

Performance varies by input:

Text files: Fast processing
Archives: Depends on extraction time
AI/Images: Limited by API response time

Can I process large directories?

Yes, Seedx can scan entire directory trees:

Recursive file discovery
Archive extraction up to 3 levels
Progress tracking for all files

Why is processing slow?

Common causes:

AI processing: API calls have latency
Large archives: Extraction takes time
Many small files: File system overhead
Disk I/O: Use SSD for better performance

How much RAM do I need?

RAM requirements depend on your workload:

Text processing requires less RAM
Large archives require more RAM
Monitor usage and adjust accordingly

Detection

What seed phrase languages are supported?

Multiple BIP39 wordlists:

English (default)
Spanish
French
Italian
Portuguese
Czech
Japanese
Korean
Chinese (Simplified/Traditional)

Are partial seed phrases detected?

Seedx looks for complete valid phrases (12, 15, 18, 21, or 24 words). Partial phrases are not extracted.

What private key formats are detected?

Hexadecimal (64 characters)
Base58 (Bitcoin WIF)
Base58Check
Various altcoin formats

Can Seedx detect encrypted seeds?

No, Seedx finds plaintext seed phrases. Encrypted or encoded seeds require decryption first.

Output

Where are results saved?

Default output structure:

output_dir/
├── seeds.txt              # Found seed phrases
├── private_keys.txt       # Cryptocurrency keys
├── other_secrets.txt      # API keys & tokens
└── csv/
    ├── seeds.csv          # CSV with source info
    ├── private_keys.csv   # CSV with source info
    └── other_secrets.csv  # CSV with source info

What’s in the CSV files?

CSV files contain the same data as text files plus metadata:

Source file path where secret was found
Secret type/name for categorization

Can I customize output format?

Output format is standardized for compatibility. Use the CSV files for source tracking.

Are duplicates removed?

By default, yes. Each unique seed/key appears once in output.

Troubleshooting

No results found

Verify input files contain seed phrases
Check file format is supported
Enable AI for image-based sources
Review detection settings
Test with known sample file

AI extraction failing

Ensure images are readable
Check image quality and format
Try individual images first
Check network connectivity

“Invalid seed phrase” in results

The phrase was detected but may be:

Missing words
Misspelled beyond correction
Invalid word order
Non-BIP39 format

Archive extraction errors

Archive may be corrupted
Incorrect password
Unsupported compression
Insufficient disk space

High false positive rate

Adjust detection sensitivity
Enable stricter validation
Filter results by confidence
Review source data quality

Security

Is my data safe?

Seedx processes files locally on your machine:

Text/document processing is fully local
Images sent to Quantium OCR service for processing
Results stay on your machine

Should I use this on production wallets?

Seedx is for data analysis and recovery. Never expose active wallet seeds unnecessarily.

How do I securely delete results?

Use secure delete tools
Overwrite files multiple times
Clear system caches
Consider encrypted storage

Best Practices

Recommended workflow

Organize sources: Separate images from text files
Text first: Process text files (faster)
AI second: Process images only if needed
Review results: Verify findings manually
Secure storage: Encrypt sensitive results

Handling sensitive data

Process on air-gapped machine if possible
Encrypt results immediately
Limit access to output files
Delete source files after processing

Vanadum

Next-gen TLS API with modern encryption and peak throughput for demanding network applications.

Overview

Vanadum is a local HTTP proxy server that provides advanced TLS fingerprint emulation. It allows you to make HTTP requests that are indistinguishable from real browser traffic, bypassing sophisticated bot detection systems.

Key Features

Browser Emulation: Mimics Chrome, Safari, Edge, Firefox, and OkHttp
Anti-Fingerprinting: Bypasses TLS/JA3/JA4/HTTP2 detection
Proxy Support: HTTP, HTTPS, SOCKS4, SOCKS5
High Performance: Optimized for throughput with connection pooling
Easy Integration: Simple HTTP API on localhost

How It Works

Vanadum runs as a local server on http://127.0.0.1:8000
You send requests to Vanadum with target URL in headers
Vanadum makes the request with browser-like TLS fingerprint
Response is returned to your application

Quick Start

Launch Vanadum from Quantium launcher
Server starts automatically on port 8000
Send requests using any HTTP client:

curl -X GET "http://localhost:8000/" \
     -H "X-Url: https://example.com" \
     -H "X-Profile: chrome"

Use Cases

Web scraping with anti-bot bypass
API automation requiring browser fingerprints
Testing and development of web applications
Integration with automation tools

Features

Browser Profiles

Available Profiles

chrome - Chrome browser emulation (versions 100-142)
safari - Safari browser emulation (versions 15.3-26)
edge - Microsoft Edge (versions 101-134)
firefox - Mozilla Firefox (versions 109-143)
okhttp - OkHttp client (versions 3.9-5)
opera - Opera browser (versions 116-119)
custom - Dynamic fingerprint generation
http11 - Force HTTP/1.1 protocol

Supported Browser Versions

Chrome (34 versions)

100, 101, 104, 105, 106, 107, 108, 109, 110, 114, 116, 117, 118, 119, 120, 123, 124, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142

Safari (22 versions)

Desktop: 15.3, 15.5, 15.6.1, 16, 16.5, 17.0, 17.2.1, 17.4.1, 17.5, 18, 18.2, 18.3, 18.3.1, 18.5, 26
iOS: 16.5, 17.2, 17.4.1, 18.1.1, 26
iPad: 18, 26

Edge (5 versions)

101, 122, 127, 131, 134

Firefox (12 versions)

109, 117, 128, 133, 135, 136, 139, 142, 143

Private mode: 135, 136
Android: 135

Opera (4 versions)

116, 117, 118, 119

OkHttp (8 versions)

3.9, 3.11, 3.13, 3.14, 4.9, 4.10, 4.12, 5

Custom Profile

Generates unique but valid fingerprints with:

Randomized cipher suites
Various Chrome versions
Different curve configurations
Stable variations per instance

TLS Emulation

Fingerprint Components

TLS handshake parameters
Cipher suite ordering
Extension configurations
HTTP/2 settings and frames
Header ordering
Client hints (sec-ch-ua)

Anti-Detection

Bypasses JA3/JA4 fingerprinting
Defeats HTTP/2 fingerprinting
Mimics real browser behavior
Randomizes detectable patterns

Proxy Support

Vanadum supports all standard proxy types with per-request configuration.

See Working with Proxies for detailed proxy documentation.

Performance

Optimization

Connection pooling
Keep-alive support
Compression (gzip, brotli, zstd, deflate)
Concurrent request handling

Configuration

Timeout control
Redirect limits
Header manipulation
Request/response logging

Integration

Compatible Tools

Private Keeper
Silver/OpenBullet
Custom automation scripts
Any HTTP client

API Design

Simple HTTP interface
Header-based configuration
Standard HTTP methods
JSON/text/binary responses

API Reference

Endpoint

http://127.0.0.1:8000/

All requests go to the root endpoint. The target URL and options are specified via headers.

Request Headers

Required Headers

X-Url

The target URL to request.

X-Url: https://example.com/api/data

Optional Headers

X-Profile

Browser profile to emulate. Default: chrome

X-Profile: chrome|safari|edge|firefox|okhttp|custom|http11

X-Proxy

Proxy server URL with optional authentication.

X-Proxy: http://proxy.example.com:8080
X-Proxy: http://user:[email protected]:8080
X-Proxy: socks5://user:[email protected]:1080

X-Timeout

Request timeout in seconds. Default: 30

X-Timeout: 60

X-Redirect

Maximum number of redirects to follow. Default: 10

X-Redirect: 5

X-Shuffle

Shuffle request headers. Default: false

X-Shuffle: true

Request Methods

All standard HTTP methods are supported:

GET
POST
PUT
DELETE
PATCH
HEAD
OPTIONS

Request Body

Pass request body as you would with any HTTP client. Supports:

JSON
Form data
Plain text
Binary data

Examples

Basic GET Request

curl -X GET "http://localhost:8000/" \
     -H "X-Url: https://api.example.com/users"

POST with JSON

curl -X POST "http://localhost:8000/" \
     -H "X-Url: https://api.example.com/users" \
     -H "Content-Type: application/json" \
     -d '{"name": "John Doe"}'

Using Proxy

curl -X GET "http://localhost:8000/" \
     -H "X-Url: https://example.com" \
     -H "X-Proxy: socks5://user:[email protected]:1080" \
     -H "X-Profile: firefox"

Custom Headers

curl -X GET "http://localhost:8000/" \
     -H "X-Url: https://api.example.com/data" \
     -H "Authorization: Bearer token123" \
     -H "X-Custom-Header: value"

Response

The response from the target server is returned as-is, including:

Status code
Headers
Body
Cookies

Error Handling

Errors are returned with appropriate HTTP status codes:

400: Bad request (missing X-Url header)
500: Internal server error
502: Bad gateway (target server error)

Examples

Simple examples showing how to use Vanadum from different programming languages.

Python

import requests

# Basic GET request
response = requests.get(
    'http://localhost:8000/',
    headers={
        'X-Url': 'https://httpbin.org/get'
    }
)

print(response.text)

# POST request with data
response = requests.post(
    'http://localhost:8000/',
    headers={
        'X-Url': 'https://httpbin.org/post'
    },
    json={'key': 'value'}
)

print(response.json())

# Using with proxy and different profile
response = requests.get(
    'http://localhost:8000/',
    headers={
        'X-Url': 'https://api.ipify.org?format=json',
        'X-Profile': 'firefox',
        'X-Proxy': 'http://proxy.example.com:8080'
    }
)

print(response.text)

TypeScript

// Basic GET request
const response = await fetch('http://localhost:8000/', {
  headers: {
    'X-Url': 'https://httpbin.org/get',
  },
});

const data = await response.text();
console.log(data);

// POST request with data
const postResponse = await fetch('http://localhost:8000/', {
  method: 'POST',
  headers: {
    'X-Url': 'https://httpbin.org/post',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ key: 'value' }),
});

const postData = await postResponse.json();
console.log(postData);

// Using axios (alternative)
import axios from 'axios';

const axiosResponse = await axios.get('http://localhost:8000/', {
  headers: {
    'X-Url': 'https://api.ipify.org?format=json',
  },
});

console.log(axiosResponse.data);

Rust

use reqwest;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    // Create client
    let client = reqwest::Client::new();

    // Basic GET request
    let response = client
        .get("http://localhost:8000/")
        .header("X-Url", "https://httpbin.org/get")
        .send()
        .await?;

    let text = response.text().await?;
    println!("{}", text);

    // POST request with JSON
    let mut map = HashMap::new();
    map.insert("key", "value");

    let post_response = client
        .post("http://localhost:8000/")
        .header("X-Url", "https://httpbin.org/post")
        .json(&map)
        .send()
        .await?;

    let post_text = post_response.text().await?;
    println!("{}", post_text);

    Ok(())
}

Go

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)

func main() {
    // Basic GET request
    req, err := http.NewRequest("GET", "http://localhost:8000/", nil)
    if err != nil {
        panic(err)
    }

    req.Header.Set("X-Url", "https://httpbin.org/get")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    // POST request with JSON
    payload := map[string]string{"key": "value"}
    jsonData, _ := json.Marshal(payload)

    postReq, err := http.NewRequest("POST", "http://localhost:8000/", bytes.NewBuffer(jsonData))
    if err != nil {
        panic(err)
    }

    postReq.Header.Set("X-Url", "https://httpbin.org/post")
    postReq.Header.Set("Content-Type", "application/json")

    postResp, err := client.Do(postReq)
    if err != nil {
        panic(err)
    }
    defer postResp.Body.Close()

    postBody, _ := io.ReadAll(postResp.Body)
    fmt.Println(string(postBody))
}

Headers Reference

Required Headers

X-Url: The target URL you want to fetch

Optional Headers

X-Profile: Browser profile to emulate (chrome, safari, edge, firefox, okhttp, custom, http11) - defaults to chrome
X-Proxy: Proxy server in various formats - see Working with Proxies for all supported formats
X-Timeout: Request timeout in seconds (default: 30)
X-Redirect: Maximum number of redirects to follow (default: 10)
X-Shuffle: Shuffle request headers (true/false, default: false)

Standard HTTP Headers

All standard HTTP headers (User-Agent, Accept, Cookie, etc.) are passed through to the target server.

Tips

Default Profile: If not specified, Vanadum uses Chrome profile by default
Error Handling: Check the response status code - Vanadum returns the target server’s status
Proxy Rotation: Change the X-Proxy header for each request to rotate proxies

Advanced Usage

Custom Headers

response = requests.get(
    'http://localhost:8000/',
    headers={
        'X-Url': 'https://example.com/api',
        'Authorization': 'Bearer token123',
        'Custom-Header': 'custom-value'
    }
)

Using Different Profiles

# Safari profile for iOS-like requests
resp1 = requests.get('http://localhost:8000/', headers={
    'X-Url': 'https://example.com',
    'X-Profile': 'safari'
})

# Firefox profile
resp2 = requests.get('http://localhost:8000/', headers={
    'X-Url': 'https://example.com',
    'X-Profile': 'firefox'
})

# Custom profile for special cases
resp3 = requests.get('http://localhost:8000/', headers={
    'X-Url': 'https://example.com',
    'X-Profile': 'custom'
})

Configuration

Server Settings

Port

Vanadum runs on port 8000 by default. This is currently not configurable.

Address

Binds to 127.0.0.1 (localhost only) for security.

Performance

Connection Pool

Maintains persistent connections
Reuses connections for same host
Automatic cleanup of idle connections

Timeouts

Default request timeout: 30 seconds
Configurable per-request via X-Timeout header
Connection timeout: 10 seconds

Security

URL Filtering

Built-in blacklist prevents requests to certain URLs.

Local Only

Server only accepts connections from localhost.

Logging

Console Output

Shows server startup
Logs requests and responses
Displays errors and warnings

Integration Tips

High Volume

Use connection pooling in your client
Batch requests when possible
Monitor memory usage

Error Handling

Implement retry logic
Handle timeout errors
Check response status codes

Testing

Use http11 profile for simpler debugging
Enable verbose logging
Test with different profiles

FAQ

General Questions

What is Vanadum?

Vanadum is a local HTTP proxy server that provides advanced TLS fingerprint emulation. It makes your HTTP requests appear as if they come from real browsers, bypassing bot detection systems.

How does it work?

Vanadum runs on http://127.0.0.1:8000
Send requests to Vanadum with target URL in headers
Vanadum makes the request with browser-like fingerprints
Response is returned to your application

What can it bypass?

TLS fingerprinting (JA3/JA4)
HTTP/2 fingerprinting
Browser detection
Anti-bot systems like Cloudflare, Akamai, PerimeterX

Do I need to modify my code?

Minimal changes - just point your HTTP client to Vanadum’s localhost address and add headers for target URL and profile selection.

Browser Profiles

What profiles are available?

Available profile categories:

Chrome: Multiple versions
Safari: iOS, macOS, iPad variants
Firefox: Including Private and Android
Edge: Multiple versions
Opera: Multiple versions
OkHttp: Multiple versions
HTTP/1.1 Only: Forces HTTP/1.1 for problematic servers
Custom: Dynamic fingerprint with randomized parameters

How do I choose a profile?

Use the X-Profile header with comma-separated values:

X-Profile: chrome,firefox

Vanadum randomly selects from the specified profiles for each request.

Can I customize profiles?

Use the “Custom” profile for dynamic fingerprint generation with randomized parameters.

Which profile has the best success rate?

Chrome generally has the highest success rate as it’s the most common browser. Safari works well for iOS-targeted sites. Use multiple profiles for automatic rotation.

API Usage

What headers are required?

Required:

X-Url: Target URL to fetch

Optional:

X-Profile: Browser profile (default: chrome)
X-Proxy: Proxy server to use

How do I use proxies?

Add the X-Proxy header:

X-Proxy: socks5://user:[email protected]:1080

What HTTP methods are supported?

All standard methods:

GET, POST, PUT, DELETE, PATCH
HEAD, OPTIONS

How do I send POST data?

Send POST data in the request body as normal. Vanadum forwards it with the correct content-type.

Can I set custom headers?

Yes, include any headers in your request. Vanadum forwards them while adding browser fingerprint headers.

Performance

How many concurrent requests can it handle?

Depends on your system resources and network capacity.

Why are requests slow?

Proxy latency: External proxies add delay
Target server: Site response time varies
Connection setup: TLS handshake takes time
Rate limiting: Target site may throttle

Does it support connection pooling?

Yes, Vanadum maintains connection pools for improved performance with repeated requests to the same host.

What timeout should I use?

Recommended timeouts:

Direct connection: 10-15 seconds
With proxies: 20-30 seconds

Troubleshooting

“Connection refused” error

Verify Vanadum is running
Check it’s on port 8000
Ensure localhost is accessible
Restart Vanadum if needed

Requests still getting blocked

Try different browser profile
Use residential proxies
Add delays between requests
Check for JavaScript challenges

“Invalid X-Url” error

URL must be complete (include https://)
URL must be properly encoded
Check for invalid characters

Timeout errors

Increase timeout setting
Check proxy connectivity
Verify target site is accessible
Reduce concurrent requests

SSL/TLS errors

Target site may have certificate issues
Try different profile
Check system time/date
Update system certificates

Integration

Python example

import requests

response = requests.get(
    "http://127.0.0.1:8000/",
    headers={
        "X-Url": "https://example.com",
        "X-Profile": "chrome"
    }
)

Node.js example

const response = await fetch('http://127.0.0.1:8000/', {
  headers: {
    'X-Url': 'https://example.com',
    'X-Profile': 'chrome',
  },
});

cURL example

curl -X GET "http://localhost:8000/" \
     -H "X-Url: https://example.com" \
     -H "X-Profile: chrome"

Can I use it with Selenium/Puppeteer?

Vanadum is for direct HTTP requests. For browser automation, use Puppeteer/Playwright with stealth plugins instead.

Security

Is traffic encrypted?

Local traffic to Vanadum: Not encrypted (localhost)
Vanadum to target: Encrypted (TLS)
Proxy connections: Depends on proxy protocol

Can I use it for sensitive data?

Yes, but understand:

Local traffic is unencrypted
Target site receives browser-like TLS
Use SOCKS5 for end-to-end encryption with proxies

Does Vanadum log requests?

Only for debugging purposes. Logs can be disabled. No data is sent to Quantium servers.

Best Practices

Avoid detection

Rotate profiles periodically
Use residential proxies
Add random delays
Mimic human behavior patterns
Don’t hammer endpoints

Optimal configuration

Use connection pooling for same-host requests
Set appropriate timeouts
Match profile to target audience
Test with small batches first

When to use different profiles

Chrome: Default, works for most sites
Safari: iOS/Mac-targeted sites
Firefox: Privacy-focused sites
Edge: Microsoft services
OkHttp: Mobile app APIs

Rapid

High-performance email checker with 15M+ mail server database, supporting IMAP and web authentication for Outlook/Hotmail.

Overview

Rapid is a professional email credential validator that checks email:password combinations across multiple protocols and providers. It features intelligent protocol detection, search capabilities, mail viewing, and comprehensive result categorization.

Key Features

Multi-Protocol Support: IMAP and web-based authentication
Email Search: Search content across all folders or specific mailboxes
Mail Viewer: Built-in GUI for viewing email content directly
Country Detection: Automatic categorization by email country
Proxy Rotation: Advanced proxy management with multiple strategies
Cookie Extraction: Save authentication cookies for web-based providers
Real-time Statistics: Live monitoring of success rates and processing speed
Free Captcha Solver: Built-in solver for web protocols

Supported Providers

IMAP

Database Power! Rapid includes a database of 15+ million email servers and automatically discovers new servers via MX record lookup. Works with any email provider that supports IMAP.

Web Authentication

Hotmail/Outlook: Direct web login for Microsoft domains

Quick Start

Launch Rapid from Quantium launcher
Load email:password list
Configure protocol preferences
Add proxies (optional)
Start checking

Output Files

Smart Organization Rapid automatically categorizes all results for easy analysis

Result Files

success.txt - Valid credentials
failed.txt - Invalid passwords
2fa.txt - Two-factor authentication required
locked.txt - Locked or disabled accounts
errors.txt - Connection errors and timeouts
protocol_mismatch.txt - Wrong protocol for domain

Directories

search_results/ - Email search matches
email_bodies/ - Downloaded email content (IMAP only)
cookies/ - Authentication cookies (Web providers)
countries/ - Results organized by country

Features

Email Checking

Protocol Support

IMAP: Standard IMAP protocol for email servers
Web Authentication: Direct web login for Hotmail/Outlook

Intelligent Detection

Automatic protocol selection based on domain
IMAP for standard email providers
Web authentication for Microsoft domains

Mail Viewer

Built-in Email Reader

View Emails: Read email content directly in the GUI
Navigate Folders: Browse INBOX, Sent, Drafts, and custom folders
Preview Messages: Quick preview of email subjects and senders
HTML Rendering: Proper display of formatted emails
Attachment Info: View attachment names and sizes

Usage

Check credentials as normal
Click on any successful result
Use Mail Viewer to browse and read emails
Navigate between folders and messages

Search Capabilities

Search Types

Body Search: Find text in email content
Subject Search: Search email subjects
From/To Search: Find emails by sender/recipient
Text Search: General text search
Custom Search: Advanced IMAP search queries

Search Options

Search specific folders or all folders
Download matching email bodies (IMAP only)
Configurable result limits
Real-time match counter

Country Detection

Automatic Categorization

Detects country from email domain
Supports many country-specific domains
Organizes results by country
Real-time country statistics

Supported Countries

Major providers (US, UK, DE, FR, etc.)
Regional variants (hotmail.co.uk, etc.)
Business domains by country

Proxy Management

Rotation Strategies

Round-Robin: Even distribution across all proxies
Random: Random selection per request
Consecutive: Sticky assignment for session persistence

Proxy Features

Support for HTTP/SOCKS4/SOCKS5
Authentication support (user:pass)
Auto-refresh from URL
Protocol override option

See Working with Proxies for detailed proxy configuration.

Performance

Multi-threading

Configurable worker threads
Parallel credential checking
Queue-based task distribution
Thread-safe result writing

Optimization

Connection pooling
Smart timeout management
Batch result processing
Memory-efficient streaming

Result Management

Status Categories

Success: Valid login
Failed: Invalid password
2FA: Two-factor authentication required
Locked: Account disabled or suspended
Protocol Mismatch: Wrong protocol for domain
Error: Connection issues or timeouts

Output Options

Organized by status
Country-specific folders
Search match results
Cookie storage (Web authentication providers)
Email body downloads (IMAP only)

Advanced Features

Saves web authentication cookies (Hotmail/Outlook)
Enables session persistence
Useful for further automation

Captcha Solving

Free solver included!

Built-in server solver for supported providers
No configuration required
Automatic captcha handling

Database

15+ Million Email Servers Pre-Configured

Automatic server detection by domain
MX record fallback for unknown domains
No manual configuration needed

Providers

IMAP Providers

15+ Million Email Servers Built-In

Rapid automatically detects IMAP servers for all email domains using its massive built-in database. For domains not in the database, it automatically discovers servers via MX record lookup. No manual configuration needed - just load your credentials and start checking.

Web Authentication Providers

Hotmail/Outlook

Supported Domains

hotmail.com, hotmail.co.uk, hotmail.fr, hotmail.de
outlook.com, outlook.es, outlook.fr
live.com, live.ca, live.co.uk
msn.com

Features

OAuth2-based web authentication
Cookie extraction
No app passwords needed
Handles security challenges

Protocol Selection

Automatic Detection

Rapid automatically selects the best protocol:

Checks domain against web authentication provider list
Uses IMAP for all other domains
Finds IMAP server from 15M+ database or MX records

Manual Override

You can force specific protocols:

Set preferred protocol in settings
Disable web authentication

Configuration

Credentials

Input File

Credentials File: Load email:password list (required)

Protocols

Available Protocols

IMAP: Standard email protocol (default: enabled)
Hotmail/Outlook: Web authentication for Microsoft

Proxy Strategy

Round Robin: Even distribution (default)
Random: Random proxy selection
Consecutive: Sticky proxy assignment

Search

Search Settings

Search Mailbox: Target folder (default: INBOX)
Search All Folders: Check all mailboxes (IMAP only)
Download Email Bodies: Save matched emails (IMAP only - BETA)
Max Bodies Per Search: 1-100 (default: 10)

Search Queries

Search Type: Body, From, Body & From, Subject, To, All Text
Query: Search text
Multiple queries supported

Proxies

Proxy Source

File: Load from local file
URL: Load from remote URL with auto-refresh

Proxy Settings

Override Protocol: Disabled/HTTP/SOCKS4/SOCKS5 (default: disabled)
Auto-refresh: Update proxies periodically
Refresh Interval: 10-3600 seconds

⚠️ Critical: Most proxy providers do NOT support IMAP! See our comprehensive proxy guide for detailed requirements and recommendations.

See Working with Proxies for proxy formats.

Captcha Solvers

Available Services

Server Solver: FREE built-in solver (included)

No configuration needed - captcha solving is automatic.

Performance

Settings

Thread Count: Number of concurrent workers
Timeout: Request timeout in seconds
Retry Count: Number of retry attempts
Delay: Delay between requests in milliseconds

Additional Options

Country Categorization: Sort by email country (BETA)
Save Cookies: Store auth cookies (BETA)

Working with Proxies

Critical Information: Proxy selection is crucial for successful email checking. This guide covers everything you need to know about using proxies with Rapid.

Important Proxy Requirements

IMAP Protocol Support

Most proxy providers do NOT support IMAP protocol! This is the #1 cause of proxy errors.

Before purchasing: Contact your proxy provider’s support and specifically ask: “Do your proxies support IMAP protocol connections?”
If they don’t know: The answer is probably no
Common errors: “Proxy error”, “Connection failed” - usually means IMAP is blocked

Web Protocol Requirements

Web protocols (Hotmail/Outlook) have different requirements:

Always require proxies: These protocols will fail without proxies due to rate limiting
Residential recommended: High-quality residential proxies work best
Higher ban risk: Server proxies may get accounts locked, especially on web protocols

Proxy Types Comparison

Residential Proxies

Pros:

Best success rates for web protocols
Lower ban risk
Harder to detect

Cons:

Slower speeds (may require retry settings)
More expensive
Variable quality

Best for: Web protocols (Hotmail/Outlook)

Datacenter/Server Proxies

Pros:

Much faster speeds
More affordable
Consistent performance

Cons:

Higher detection risk
May trigger account locks on web protocols
Some providers block IMAP

Best for: IMAP checking (if provider supports IMAP)

Public/Free Proxies

Never use public proxies!

Email providers actively block them
Extremely high failure rates
Security risks
Will get accounts locked

Optimal Configurations

IMAP Only (Fastest)

Protocol: IMAP only
Proxies: None (direct connection) or datacenter with IMAP support
Timeout: Lower values work well
Retry: Optional

Note: Some IMAP servers may block direct connections from certain IPs

Web Protocols (Hotmail/Outlook)

Protocols: Hotmail/Outlook
Proxies: High-quality residential proxies (required!)
Timeout: Higher values recommended
Retry: Enable retries for better success
Proxy Strategy: Round Robin

Troubleshooting Proxy Issues

“Proxy Error” Messages

Check IMAP support with your provider
Test proxy format: protocol://user:pass@ip:port
Verify proxy is alive using external tools
Try different proxy type (HTTP/SOCKS5)

High Failure Rates

Reduce thread count - oversaturation causes failures
Increase timeout - residential proxies are slower
Enable retries - temporary network issues
Check proxy quality - test manually first

Account Locks

Use residential proxies for web protocols
Reduce threads to appear more human
Add delays between requests
Rotate proxies more frequently

Provider Recommendations

For IMAP

Ask providers specifically about:

IMAP protocol support
Port 993 (IMAPS) availability
Email service compatibility

For Web Protocols

Look for:

Residential IP pools
Browser fingerprinting
Session persistence
Geographic diversity

Performance Tips

Speed Optimization

No proxies for IMAP when possible (fastest)
Datacenter proxies for IMAP if needed
Adjust timeouts based on proxy type
Monitor statistics to find optimal settings

Success Rate Optimization

Test proxies first before bulk checking
Use proxy strategy that fits your list
Separate protocols - run IMAP and web separately
Quality over quantity - fewer good proxies beat many bad ones

Security Considerations

Never share proxy lists - they’re tied to your account
Rotate regularly - don’t overuse same proxies
Monitor for leaks - check your real IP isn’t exposed
Use HTTPS proxies when available

Remember: The right proxy setup significantly impacts success rates.

FAQ

General Questions

Why are some emails failing with “protocol mismatch”?

Hotmail/Outlook domains require web authentication, not IMAP. Rapid automatically selects the correct protocol, but if you’ve forced IMAP-only mode, these will fail.

What’s the difference between 2FA and locked results?

2FA: Account requires two-factor authentication to access
Locked: Account has been disabled or suspended by the provider

How do I use the Mail Viewer?

Complete a check with successful results
Click on any successful credential in the results
The Mail Viewer opens showing the inbox
Navigate folders and click emails to read content

Can I download attachments?

Yes, the Mail Viewer supports downloading and saving attachments from emails.

Performance

How many threads should I use?

Start with a low thread count and gradually increase while monitoring:

System resource usage (CPU, RAM)
Proxy performance and errors
Success/failure rates

Higher thread counts require better hardware and quality proxies.

Why is checking slow?

Common causes:

Proxy quality: Bad proxies cause timeouts and retries
Thread count too high: Can overwhelm system or proxies
Provider rate limits: Some servers throttle connections
Network latency: Distance to email servers

Can I check multiple lists at once?

Yes, run multiple instances of Rapid with different output directories. Each instance uses its own thread pool.

What timeout should I use?

No proxies / Fast proxies: 10-15 seconds
Residential proxies: 20-30 seconds
Slow connections: 30-60 seconds

Higher timeouts reduce failures but slow overall processing.

Why do I get many “Error” results?

Common causes:

Bad proxy quality
Timeout too low
Provider blocking connections
Network issues

Try reducing threads, increasing timeout, or using better proxies.

Search Features

What does “search all folders” do?

Instead of just searching INBOX, it searches all email folders (Sent, Drafts, Spam, Archives, etc.) for your query.

Are searches case-sensitive?

Email searches are typically case-insensitive, but this depends on the email server implementation.

Can I search for multiple terms?

Yes, add multiple search queries in the configuration. Each query is searched independently, and all matches are saved.

What’s the difference between body and text search?

Body Search: Searches only the email body/content
Text Search: Searches headers, subject, and body combined

How do I search for emails from a specific sender?

Use the “From” search type and enter the sender’s email address or domain.

Proxies

Which proxy type is best?

SOCKS5 offers the best compatibility. HTTP proxies work but may have limitations with some protocols.

Do I need proxies?

IMAP without search: Works fastest without proxies (direct connection)
IMAP with search: Some servers block direct connections
Web protocols (Hotmail): Always require proxies due to rate limiting

Why are my proxies failing?

Most proxy providers don’t support IMAP protocol! See our comprehensive proxy guide for detailed troubleshooting.

Common issues:

Provider blocks port 993 (IMAP)
Proxy format incorrect
Credentials expired
Proxy is dead/offline

What’s the “proxy error” message mean?

Usually means your proxy provider blocks IMAP connections. Contact their support to confirm IMAP protocol support on port 993.

What proxy rotation strategy should I use?

Round-Robin: Best for balanced load across all proxies
Random: Good for avoiding patterns
Consecutive: Best for session-based operations

Can I use free/public proxies?

Never use public proxies:

Email providers actively block them
Extremely high failure rates
Security risks (MITM attacks)
Will get accounts locked

Protocols

Why can’t I use IMAP for Hotmail/Outlook?

Microsoft disabled basic IMAP authentication. Only OAuth2 or web login works. Rapid uses web authentication to handle this automatically.

What providers support web authentication?

Currently supported:

hotmail.com and variants
outlook.com and variants
live.com and variants
msn.com

Will you add more web authentication providers?

We continuously add new providers based on demand. Contact support with specific requests.

What about Gmail?

Gmail uses OAuth2 which requires user interaction. Currently, Rapid supports Gmail only via IMAP with app passwords.

Output Files

Cookies from web authentication (Hotmail/Outlook) can be:

Imported into browsers for continued access
Used with automation tools
Stored for later verification

Can I resume interrupted checking?

Remove already-checked emails from your input file and run again. Or use different output directory and combine results later.

What format are results saved in?

Results are saved as plain text files with email:password format, organized by status (success, failed, 2fa, locked, errors).

Where are downloaded email bodies saved?

In the email_bodies/ subdirectory of your output folder, organized by email address.

Captcha

How does the captcha solver work?

Rapid includes a built-in solver that handles captchas automatically. It’s completely free and requires no configuration.

Country Detection

How does country detection work?

Rapid analyzes the email domain to determine the country:

TLD analysis (.de, .fr, .uk)
Known provider mapping
Domain pattern matching

Why are some countries wrong?

Some domains don’t follow country patterns (e.g., .com used worldwide). The detection is based on domain patterns, not actual location.

Troubleshooting

Tool crashes during checking

Reduce thread count
Check available memory
Verify proxy list format
Try smaller input file first

All results show as “Error”

Check internet connection
Verify proxy configuration
Test proxies manually
Try without proxies (IMAP only)

Results don’t match expected count

Check for:

Duplicate credentials in input

Mail Viewer shows blank content

Email may be HTML-only - check rendering settings
Connection may have timed out - try reopening
Account may have been locked since checking

Common Data Formats

Credential Formats

Quantium tools support multiple credential formats with flexible parsing.

URL:Login:Password

https://example.com:admin:password123
http://site.org:user:pass456
example.com:username:secret

Login:Password:URL

admin:password123:https://example.com
user:pass456:site.org

Login:Password

username:password
admin:secret123

Email:Password

[email protected]:password123
[email protected]:pass456

When using email format:

Domain is extracted from email domain
Username is extracted from email prefix

Delimiters

All formats support these delimiters:

: (colon) - most common
; (semicolon)
| (pipe)
(space)

Proxy Formats

See Working with Proxies for detailed proxy format documentation.

CSV Formats

Standard CSV

email,password,name
[email protected],pass123,John Doe

Configurable Options

Delimiters: comma, semicolon, tab, custom
Headers: Optional first row with column names
Quoting: Standard CSV quoting rules apply

Working with Proxies

Overview

Most Quantium tools support proxy servers for network operations. This allows you to route traffic through intermediary servers for privacy, access control, or geographic requirements.

Supported Proxy Types

HTTP/HTTPS

Standard web proxies
Support authentication
Compatible with all tools

SOCKS4

TCP connections only
Userid authentication only
Lightweight protocol

SOCKS5

TCP and UDP support
Username/password authentication
Most versatile option

Proxy Formats

Quantium tools accept proxies in multiple formats:

URL Format (Recommended)

protocol://user:pass@host:port

Examples:

http://proxy.example.com:8080
http://user:[email protected]:8080
socks5://user:[email protected]:1080
socks4://[email protected]:1080

Alternative Formats

host:port:user:pass
host:port@user:pass
user:pass:host:port
host:port

If no protocol is specified, SOCKS5 is assumed.

Loading Proxies

From File

Create a text file with one proxy per line:

socks5://user1:[email protected]:1080
socks5://user2:[email protected]:1080
http://proxy3.com:8080

In Application

Most tools have a proxy input field or file selector. Simply:

Click “Load Proxies” or similar button
Select your proxy file
Proxies are validated and loaded

Proxy Features by Tool

Email Tools (Rapid)

Proxy rotation strategies (Round-Robin, Random, Consecutive)
Concurrent connections with configurable threads
Per-provider proxy assignment
Auto-refresh from URL

Network Tools (Vanadum)

Random proxy selection
Per-request proxy support
High-throughput optimization
Connection pooling

Proxy Rotation

Some tools support automatic proxy rotation:

Round-Robin

Evenly distributes requests across all proxies in sequence. Ensures balanced load and equal usage of all proxies.

Random

Randomly selects proxy for each operation. Good for avoiding patterns.

Consecutive/Sticky

Assigns same proxy to related operations. Useful for maintaining sessions.

Configure rotation strategy in tool settings where available.

Frequently Asked Questions

General Questions

What is Quantium?

Quantium is a comprehensive suite of high-performance tools for professionals in cybersecurity, data processing, and digital forensics. All tools are built from scratch for maximum performance and reliability.

How do I install Quantium?

Download the launcher from your account dashboard at quantium.rs
Install and run the launcher
Login with your credentials
Install any tools included in your subscription

Where can I get support?

24/7 Telegram Support: Direct access to our team
Website: quantium.rs/support
Documentation: You’re reading it!

Licensing & Security

How does licensing work?

Quantium uses hardware-locked licenses for security:

License is tied to your hardware
Tools validate license on startup
Subscription managed through your account dashboard

Is my data safe?

Quantium prioritizes security:

Memory wiping for sensitive data after processing
Professional code protection against reverse engineering

Can I use Quantium on multiple machines?

Contact support to discuss multi-machine licensing options based on your subscription level.

Performance

What are the system requirements?

OS: Windows 10/11
Storage: SSD recommended for best performance
CPU: Multi-core processor recommended

See System Requirements for full details.

How many threads should I use?

Depends on the tool and your system. Start with lower values and increase based on your hardware and results. Monitor your system resources and adjust accordingly.

Can Quantium handle very large files?

Yes! Quantium tools use streaming processing:

Handles large datasets
Minimal memory footprint through streaming
Only limited by storage space

Why is processing slow?

Common causes:

Disk I/O: Use SSD instead of HDD
Too many threads: Can overwhelm system resources
Proxy quality: For network tools like Rapid
Antivirus: May interfere with file operations

Tools

Which tool should I use for credential processing?

Chronos: Complete toolkit for url:log:pass with 10 specialized modules
Use ULP Cleaner for validation, ULP Sorter for categorization, ULP Extractor for archive mining

How do I check email credentials?

Use Rapid:

Load your email:password list
Configure protocol preferences
Add proxies (required for web protocols)
Start checking

What’s the difference between IMAP and web authentication?

IMAP: Standard email protocol, works with any email server
Web Authentication: Direct web login for Hotmail/Outlook, captures cookies

Proxies

Do I need proxies?

Depends on the tool:

Chronos: No proxies needed (local processing)
Rapid IMAP: Works without proxies but some servers may block direct connections
Rapid Web: Always require proxies (rate limiting)
Vanadum: Optional but recommended