🎯 Introduction

Welcome to Quantium - the premium software ecosystem built for professionals who demand unmatched quality, speed, and results.

🏠 Home 📚 Overview 🚀 Dashboard

What is Quantium?

Quantium is a comprehensive suite of high-performance tools designed for experts in cybersecurity, data processing, and digital forensics. Unlike typical software that wraps Python scripts in executables, every Quantium tool is built from scratch using 100% Rust core for maximum performance and reliability.

Why Choose Quantium?

Unmatched Performance

3000+ stable threads vs competitors’ 50
Process terabyte-sized files on regular hardware
10x faster with 10x less RAM usage
Custom implementations that outperform industry standards

Built for Professionals

Military-grade security with hardware-locked licenses
100% local processing - your data never leaves your machine
Memory wiping for sensitive data
Professional code protection against reverse engineering

Real Innovation

AI-powered features that actually work
Unique capabilities competitors don’t have
Continuous updates based on real user feedback
Solutions born from real-world needs, not theoretical requirements

Trusted by Experts

$6,000 deposit guarantee on LOLZTEAM
Independently verified by platform moderators
2+ years of proven track record
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 cutting-edge capabilities

🛠️ The Quantium Ecosystem

Specialized Tools for Every Professional Need

Our suite includes:

⏰ Chronos - Advanced URL:LOG:PASS processor handling billions of lines
🌱 Seedx - AI-powered crypto seed phrase parser with OCR
🩸 Ichor - Intelligent log sorter with ML categorization
🌐 Vanadum - Advanced TLS API system with browser fingerprinting
💧 Hydros - WordPress account recovery and intelligence tool
🚀 Rapid - High-performance email checker with 15M+ server database
📧 Sift - Professional email sorter with provider categorization
💬 Teletools - Telegram session manager and analyzer

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 (1TB+) 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
Each thread consumes approximately 50-100 MB RAM
Windows thread limit: ~2000 threads per process

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 cleaning, sorting, and deduplication
Hydros - Premium WordPress checker supporting any url:log:pass database

Log Analysis

Ichor - AI-powered log sorter for passwords, cookies, Telegram sessions, and crypto wallets
Seedx - Advanced seed-phrase parser for extracting crypto data from complex formats

Email Tools

Rapid - High-performance email checker with IMAP, Outlook, and Web.de support
Sift - Professional email sorter with provider categorization and DNS validation

Specialized Tools

Teletools - Telegram session manager with validation and metadata extraction
Vanadum - Next-gen TLS API with modern encryption 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

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

Getting Started

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

⏰ 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 8 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

📁 File Operations

Splitter - Split large files into chunks
Joiner - Merge multiple files
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 files of any size (tested with 1TB+ datasets)
Processes millions of lines per second
Minimal memory footprint through streaming
Automatic multi-threading based on CPU cores

💡 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

Common Use Cases

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

🧹 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

📤 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

✨ 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

✂️ 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

🔗 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

🔍 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-vx/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 10M lines
Each line consumes ~100-200 bytes in memory
Monitor RAM usage with large datasets

🌱 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 even extract text from images using cutting-edge AI technology.

✨ 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

Cryptocurrency private keys in various formats
Multiple encodings: Hex, Base58, WIF, and more

🔑 Other Secrets

API keys from 100+ 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:

seedx_output/
├── seeds.txt              # Found seed phrases
├── seeds_details.txt      # Detailed locations
├── private_keys.txt       # Cryptocurrency keys
├── private_keys_details.txt
├── other_secrets.txt      # API keys & tokens
└── other_secrets_details.txt

Pro Tip: The _details files show exact locations 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 OpenAI Vision
Use Cases: Screenshots, photos of written seeds

Detection Methods

Basic Detection

Pattern matching for word sequences
BIP39 wordlist validation
Length validation (12, 15, 18, 21, 24 words)

Enhanced Detection

Typo Correction: Fixes misspelled BIP39 words
Homoglyph Detection: Handles similar-looking characters
List Recognition: Detects numbered/bulleted lists
Multi-language: Supports all BIP39 languages

AI Detection

Sends images to OpenAI for text extraction
Processes AI responses to find seed phrases
Requires API key configuration

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

Simple Files: Just the secrets, one per line
Detail 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

AI Integration

Overview

Seedx can use AI to extract seed phrases from images - useful for screenshots, photos of written seeds, or any image containing text.

Setup

Requirements

OpenAI API key
Internet connection
Supported image formats: JPG, PNG, GIF

Configuration

Enable AI mode in settings
Enter your OpenAI API key

How It Works

Image Detection: Seedx identifies image files during scanning
API Request: Sends image to OpenAI with extraction prompt
Response Processing: Parses AI 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

Requires API credits
Internet connection needed
Processing time depends on API
Image quality affects accuracy

Privacy Note

When AI mode is enabled, images are sent to OpenAI’s servers for processing. Only use with images you’re comfortable sharing with third-party services.

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

Provider

Currently supports OpenAI only

API Configuration

Provider: OpenAI (currently only option)
Model: gpt-4o (default)
API Key: Your OpenAI API key
AI mode is always enabled for image processing

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
Costs API credits
Only for necessary images

🩸 Ichor

Intelligent log processor that extracts and categorizes cookies, passwords, Telegram sessions, and crypto wallets from directories and archives.

🎯 Overview

Ichor scans log collections to extract sensitive data, automatically categorizing credentials by service type (Banking, Crypto, Social, etc.) using AI-powered analysis. It processes archives with password cracking and provides real-time filtering.

✨ Key Features

Multi-Type Extraction: Cookies, passwords, Telegram sessions, wallets
AI Categorization: Automatic service type detection for credentials
Archive Processing: ZIP/RAR/7Z with password attempts
Real-time Filtering: Filter results during processing
Smart Organization: Group by domain, parse credentials, export summaries

🚀 Quick Start

Launch Ichor from Quantium launcher
Select directory to scan
Choose data types to extract
Configure filters (optional)
Start processing

🔍 Search Types

🍪 Cookies: Browser cookies and session data
🔐 Passwords: Stored credentials with parsing
💬 Telegram: Telegram Desktop session files
💰 Wallets: Cryptocurrency wallet files
📦 Unpack All: Extract all archives

📁 Output Structure

output/
├── cookies/       # 🍪 Grouped by domain
├── passwords/     # 🔐 Parsed credentials
├── telegram/      # 💬 Session files
├── wallets/       # 💰 Crypto wallets
├── unpacked/      # 📦 Extracted archives
└── summary.json   # 📊 Statistics

🔥 Power Feature: AI categorization automatically sorts credentials into Banking, Crypto, Social, and more!

✨ Features

Data Extraction

Cookies

Browser cookie files (Chrome, Firefox, Edge formats)
Session cookies and authentication tokens
Domain-based grouping and organization
Cookie expiration and security flag preservation

Passwords

Credential extraction from browser stores
Support for multiple formats:
- Browser password databases
- Text logs with credentials
- Structured password files
Automatic parsing to URL:Username:Password format

Telegram Sessions

Telegram Desktop tdata folders
Session files with authentication data
Support for multiple accounts
Preserves session integrity

Crypto Wallets

Bitcoin, Ethereum, and other wallets
Wallet.dat files and key stores
Browser extension wallets
Hardware wallet backups

AI Categorization

Service Detection

Automatically categorizes passwords by service type:

Banking: Financial institutions
Crypto: Cryptocurrency exchanges and wallets
Social: Social media platforms
Email: Email providers
Shopping: E-commerce sites
Gaming: Gaming platforms
Streaming: Media services
VPN: VPN and proxy services
Other: Uncategorized services

Risk Scoring

High-value targets identified
Service importance ranking
Credential sensitivity assessment

Archive Processing

Supported Formats

ZIP (including password-protected)
RAR/RAR5
7Z
Nested archives

Password Cracking

Common password list attempts
Custom password list support
Skip or retry failed archives
Recursive extraction

Filtering System

Real-time Filters

Cookie Domain: Filter cookies by domain
Password URL: Filter passwords by website
Username: Filter by username content
Password Content: Filter by password patterns

Save only matching entries
Exclude non-matching data
Apply filters during processing
Post-processing filtering

Performance

Multi-threading

Configurable thread count
Parallel file processing
Archive extraction optimization
Real-time progress tracking

Memory Management

Stream processing for large files
Configurable max file size limit
Efficient data structures
Minimal memory footprint

Output Organization

Structured Output

Organized folder hierarchy
Consistent file naming
Metadata preservation
Easy navigation

Export Options

JSON summary with statistics
CSV reports for analysis
Simple text format (url:log:pass)
Full log folder preservation

🏷️ Service Categories

AI Categorization

Ichor uses AI to automatically categorize extracted passwords by service type, helping you quickly identify high-value targets.

⚙️ Configuration

Search Settings

Data Types

Select which data to extract:

Cookies: Browser cookies and sessions
Passwords: Stored credentials
Telegram: Telegram Desktop data
Wallets: Cryptocurrency wallets
Unpack All: Extract all archives

Directory Options

Input Directory: Folder to scan
Recursive Search: Include subdirectories

Filter Settings

Domain Filter: Only cookies from specific domains
Example: google.com, facebook.com

Password Filters

URL Filter: Filter passwords by website URL
Username Filter: Match specific usernames
Password Filter: Match password patterns
Save Only Matching: Keep only filtered results

Output Settings

Organization

Group Cookies by Domain: Create domain subfolders
Parse Password Fields: Extract URL/username/password
Convert to Simple Format: Save as url:log:pass
Save Full Log Folders: Copy complete log directories

Export Options

Export Summary: Generate statistics files
JSON Format: Detailed categorized data
CSV Format: Spreadsheet-compatible reports

Advanced Settings

Archive Processing

Archive Passwords: List of passwords to try
Common passwords included by default
Add custom passwords for specific archives

Performance

Thread Count: Parallel processing threads
Max File Size: Skip files larger than limit (default: 100MB)

Output Control

Sort Passwords: Alphabetical sorting
Remove Duplicates: Filter duplicate entries
Preserve Metadata: Keep file timestamps

Processing Modes

Quick Scan

Fast processing
Skip large files
Basic extraction only

Deep Scan

Process all file sizes
Attempt all archive passwords
Complete extraction

Filter-Only Mode

Apply filters to existing results
No new extraction
Fast reorganization

🌐 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 - Latest Chrome fingerprint
safari - Safari browser emulation
edge - Microsoft Edge
firefox - Mozilla Firefox
okhttp - OkHttp client
custom - Dynamic fingerprint generation
http11 - Force HTTP/1.1 protocol

Custom Profile

Generates unique but valid fingerprints with:

Randomized cipher suites
Various Chrome versions (100-136)
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

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
Performance: Vanadum adds minimal overhead (~5-10ms) to requests

🚀 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

💧 Hydros

WordPress security testing tool for credential validation and information gathering.

🎯 Overview

Hydros tests WordPress credentials, discovers subdomains, enumerates usernames, and extracts WooCommerce data. It supports bulk testing with proxy rotation and comprehensive subdomain scanning.

✨ Key Features

Credential Testing: Validate WordPress login credentials
Subdomain Discovery: Find WordPress on subdomains via CT logs and DNS
Username Enumeration: Discover and test additional usernames
WooCommerce Analysis: Extract payment methods and sales data
Proxy Support: Full proxy rotation for anonymization

🚀 Quick Start

Launch Hydros from Quantium launcher
Prepare credential list (see formats below)
Configure testing options
Add proxies (optional)
Start testing

📥 Input Formats

Hydros accepts credentials in standard formats. See Common Data Formats for details.

URL:Login:Password: Direct WordPress site URLs with credentials
Email:Password: Automatically extracts domain and username

📁 Output Files

output/
├── good.txt         # ✅ Valid credentials
├── bad.txt          # ❌ Invalid credentials
├── errors.txt       # ⚠️ Failed attempts
├── info.txt         # ℹ️ Additional login info
└── woocommerce.txt  # 🛒 WooCommerce data

💡 Pro Tip: Enable subdomain discovery to find hidden WordPress installations!

✨ Features

Credential Testing

WordPress Detection

Identifies WordPress installations
Locates login endpoints (wp-login.php, wp-admin)
Handles custom login URLs
Follows redirects automatically

Authentication Methods

Standard WordPress login
Cookie-based sessions
Custom authentication plugins
Two-factor bypass attempts

Result Categories

Valid: Successful login with role detection
Invalid: Wrong username/password
Error: Connection issues or timeouts

Subdomain Enumeration

Discovery Methods

Certificate Transparency: Queries crt.sh for SSL certificates
DNS Bruteforce: Tests common prefixes (www, blog, shop, mail, etc.)
Wildcard Detection: Identifies wildcard DNS configurations

Subdomain Testing

Tests each discovered subdomain for WordPress
Applies same credentials to all subdomains
Configurable subdomain limit (default: 100)
Parallel subdomain checking

Username Enumeration

Discovery Sources

WordPress REST API
Author archives
RSS feeds
Login error messages

Testing Strategy

Fetches up to 50 usernames (configurable)
Tests provided password with each username
Identifies password reuse across accounts
Continues after successful login (optional)

WooCommerce Analysis

Data Extraction

Store Status: Active/inactive, version info
Payment Methods: Configured gateways
Sales Statistics:
- Total revenue
- Order count
- Items sold
- Average order value

Admin Features

Requires administrator access
Extracts detailed configuration
Payment gateway settings
Store performance metrics

Performance

Multi-threading

Configurable workers (1-50)
Concurrent subdomain testing
Real-time CPM statistics
Progress tracking

Network Optimization

Connection pooling
Smart retry logic
Timeout management
Proxy rotation

Proxy Support

Proxy Features

Random proxy selection
HTTP/SOCKS5 support
Automatic rotation on failure
Proxy authentication

See Working with Proxies for supported proxy formats.

⚙️ Configuration

Basic Settings

Files

Bases File: Path to credentials list (required)
Proxies File: Path to proxy list (optional)

Behavior Settings

Only WordPress URLs: Process only URLs with wp-login/wp-admin (default: false)

Testing Options

Performance

Threads: Number of concurrent workers (default: 10)
Timeout: Request timeout in seconds (default: 20)
Retries: Login retry attempts (default: 1)

Limits

Max Subdomains to Try: Limit subdomain attempts (default: 10)
Max Usernames to Try: Limit username attempts (default: 10)

Behavior Settings

Subdomain Enumeration: Enable subdomain discovery (default: false)
Fetch Usernames: Fetch usernames if login fails (default: false)
Continue After Success: Continue after finding valid login (default: false)

Proxy Configuration

Proxy Settings

Proxy File: One proxy per line
Proxy Format: See Working with Proxies
Rotation: Random selection
Retry on Failure: Switch proxy on error

Output Details

File Contents

good.txt: url:username:password
bad.txt: url:username:password (failed logins)
errors.txt: url:username:password (connection errors)
errors_details.txt: url:username:password:{base64_error}
info.txt: url:username:password:role[:payments][:sales_stats]
woocommerce.txt: Detailed WooCommerce data with role, version, payments, and stats

🚀 Rapid

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

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, and comprehensive result categorization.

Key Features

Multi-Protocol Support: IMAP and web-based authentication
Email Search: Search content across all folders or specific mailboxes
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

🌐 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
GMX: Web-based authentication for GMX domains
Web.de: Web login with free AI captcha solver support

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 - BETA)
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, GMX, Web.de

Intelligent Detection

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

🔍 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 - BETA)
Configurable result limits
Real-time match counter

🌍 Country Detection

Automatic Categorization

Detects country from email domain
Supports 100+ 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, gmx.de)
Business domains by country

🔄 Proxy Management

Rotation Strategies

Round-Robin: Even distribution
Random: Random selection
Consecutive: Sticky assignment

Proxy Features

Support for HTTP/SOCKS4/SOCKS5
Authentication support
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 required
Locked: Account disabled
Protocol Mismatch: Wrong protocol
Error: Connection issues

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
Enables session persistence
Useful for further automation

Captcha Solving

Free AI-powered solver included!

Built-in server solver for Web.de
No API keys or costs required
Optional external solver support

Database

15+ Million Email Servers Pre-Configured

Automatic server detection
MX record fallback
No manual configuration needed

Filtering Options

Domain filtering
Password complexity rules
Unique password detection
Custom exclusion lists

🌐 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

Direct web login (not OAuth2)
Cookie extraction
No app passwords needed
Handles security challenges

GMX

Supported Domains

gmx.com, gmx.de, gmx.at, gmx.ch
gmx.net, gmx.fr, gmx.co.uk
gmx.us, gmx.ca

Features

Web-based authentication
Cookie saving
Automatic session handling
Multi-language support

Web.de

Supported Domains

web.de
Other web.* variants

Requirements

Captcha Required (Free built-in solver available)
Optional external solver services supported

🔌 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)

Credential Filters

Normalize Domains: Clean domain variations (default: true)
Unique Emails: Remove duplicate emails (default: false)
Unique Passwords: Remove duplicate passwords (default: false)

Advanced Filters

Include Domains: Comma-separated list of domains to include
Exclude Domains: Comma-separated list of domains to exclude
Exclude Country TLDs: Comma-separated country codes
Max Per Domain: Limit emails per domain

Password Filters

Min Length: Minimum password length
Max Length: Maximum password length
Complexity Level: Required complexity score
Require Special Characters: Must contain special chars

Protocols

Available Protocols

IMAP: Standard email protocol (default: enabled)
Hotmail/Outlook: Web authentication for Microsoft
GMX: Web authentication for GMX domains
Web.de: Web authentication (requires captcha solver)
POP3: Coming soon

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

ServerSolver: FREE built-in solver (recommended)
RuCaptcha: ~$0.39/1000 solves
2Captcha: ~$0.50/1000 solves
AntiCaptcha: ~$2.75/1000 solves
CapSolver: ~$0.40/1000 solves (not for Web.de)

Configuration

Select active solver from dropdown
Enter API key for paid services
Validate key before use

Performance

Settings

Thread Count: 1-5000 concurrent workers (default: 250)
Timeout: 5-120 seconds (default: 10)
Retry Count: 0-10 attempts (default: 0)
Delay: 0-1000ms between requests (default: 0)

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, GMX, Web.de) 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, GMX, Web.de)

🖥️ 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)
Threads: 500-1000
Timeout: 15 seconds
Retry: 0

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

IMAP with Proxies

Protocol: IMAP only
Proxies: Datacenter proxies with IMAP support
Threads: 250-500
Timeout: 20 seconds
Retry: 1-2

Web Protocols (Hotmail/GMX/Web.de)

Protocols: Hotmail, GMX, Web.de
Proxies: High-quality residential proxies (required!)
Threads: 50-150
Timeout: 30 seconds
Retry: 2-3
Proxy Strategy: Round Robin

Mixed Protocols

Protocols: All enabled
Proxies: Residential proxies
Threads: 100-250
Timeout: 25 seconds
Retry: 1-2

🔍 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 can make the difference between 10% and 90% 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

Performance

How many threads should I use?

Recommended Thread Counts:

🟢 Starter: 250 threads

🟡 Advanced: 1000 threads

🔴 Extreme: 3000 threads (for power users)

Why is checking slow?

Check your proxy quality
Reduce thread count if system is overloaded
Some providers have rate limits

Can I check multiple lists at once?

Run multiple instances of Rapid with different output directories.

Search Features

What does “search all folders” do?

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

Are searches case-sensitive?

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

Proxies

Which proxy type is best?

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

Do I need proxies?

IMAP: Works fastest without proxies, but some servers may block direct connections
Web protocols: 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.

What’s the “proxy error” message mean?

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

Web.de Specific

Is the captcha solver really free?

Yes, Rapid includes a free AI-powered captcha solver running on our servers. It automatically solves Web.de captchas without requiring API keys or payments.

Why is Web.de slower than other providers?

Web.de requires captcha solving for each login, which adds processing time.

Output Files

Cookies from web authentication providers (Hotmail, GMX, Web.de) can be imported into browsers or other tools for continued access.

Can I resume interrupted checking?

Remove already-checked emails from your input file and run again.

💬 Teletools

Telegram session checker and converter supporting tdata, Pyrogram, and Telethon formats.

🎯 Overview

Teletools validates Telegram sessions, extracts account information, and converts between different session formats. It handles bulk operations with proxy support and comprehensive data extraction.

✨ Key Features

Session Validation: Check if sessions are working, dead, banned, or require 2FA
Format Conversion: Convert between tdata, Pyrogram, and Telethon formats
Data Extraction: Account info, premium status, Stars balance, CryptoBot wallets
Proxy Support: HTTP/SOCKS5 with rotation strategies
Bulk Processing: Multi-threaded checking and conversion

🚀 Quick Start

Launch Teletools from Quantium launcher
Select operation mode (Check or Convert)
Choose session directory
Configure options
Start processing

📄 Session Formats

📦 Supported Types

Tdata: Telegram Desktop folders
Pyrogram: SQLite .session files
Telethon: SQLite and string .session files

🔄 Conversion Matrix

Tdata → Pyrogram → Telethon
Telethon → Pyrogram → Tdata
Direct conversions between any formats

📁 Output

✅ Check Mode

teletools_output/
├── results.csv          # Main account details
├── groups.csv           # Admin groups with permissions
├── channels.csv         # Admin channels with permissions
├── working/             # Valid session files (optional)
├── dead/                # Invalid sessions
└── errors/              # Failed checks

🔄 Convert Mode

Converted session files in target format
Validation report with conversion results
Failed conversion log for troubleshooting

✨ Features

Session Checking

Validation States

Working: Active session with valid authentication
Dead: Invalid or expired session
Banned: Account suspended by Telegram
2FA: Two-factor authentication required
Error: Connection or API issues

Data Extraction

User Info: ID, phone, username, name, bio
Account Flags: Premium, verified, bot, restricted, scam
Social Metrics: Contacts, groups, channels, photos
Financial Data: Stars balance, CryptoBot wallets
Bot Interactions: History with popular crypto/gaming bots

Spam Detection

Automatic check via @spambot
Restriction status and reasons
Ban expiration dates

Format Conversion

Conversion Options

Telethon Output: SQLite, String, or Memory format
Batch Processing: Convert entire directories
Validation: Verify sessions after conversion
Error Recovery: Skip corrupted sessions

API Configuration

Multiple API ID/Hash pairs support
Automatic API rotation
Custom API for specific operations

Proxy Management

Rotation Strategies

Sequential: Use proxies in order
Random: Random proxy selection
Sticky: Keep same proxy per session (Consecutive mode)

Proxy Features

HTTP/SOCKS5 support
Authentication support
Auto-refresh from file
Connection testing

See Working with Proxies for supported proxy formats.

Performance

Multi-threading

Configurable worker threads (1-50)
Rate limiting to avoid bans
Automatic retry on failures
Progress tracking with ETA

Resource Usage

Efficient memory management
Streaming file processing
Minimal CPU overhead
Smart rate limiting

📄 Session Formats

Tdata Format

Structure

tdata/
├── key_data
├── D877F783D5D3EF8C/
│   ├── configs
│   ├── maps
│   └── ...
└── ...

Requirements

Complete tdata folder from Telegram Desktop
key_data file must be present
Account folder (16-character hex)

Pyrogram Format

File Structure

session_name.session (SQLite database)

Requirements

Valid Pyrogram session file
Must be SQLite format
Contains authentication data

Telethon Format

SQLite Format

session_name.session (SQLite database)

String Format

1BVtsOGwBu7xajdEvfPP6Gze...

Base64-encoded session string.

Requirements

Valid Telethon session file or string
SQLite or base64 string format
Contains authentication data

Conversion Notes

Supported Conversions

Tdata → Pyrogram → Telethon
Telethon → Pyrogram → Tdata
All intermediate conversions

Compatibility

Preserves authentication state
Maintains datacenter assignment
API credentials required for operations

⚙️ Configuration

Check Mode

API Configuration

Format: {id}:{hash},{id}:{hash},...

Example:

2040:b18441a1ff607e10a989891a5462e627,12345:abc123def456

Getting API Credentials

Go to https://my.telegram.org
Log in with your phone number
Select “API development tools”
Create new application if needed
Copy your api_id and api_hash

Default API

You can use Telegram Desktop’s default API:

2040:b18441a1ff607e10a989891a5462e627

Session Settings

Sessions Directory: Folder containing session files
Session Type: Mixed (auto-detect), Tdata, Pyrogram, or Telethon
Search Subdirectories: Include subfolders recursively

Proxy Settings

Proxy File: Text file with proxy list
Proxy Rotation: Per Session, Sequential, or Random
Protocol Override: Auto-detect, HTTP, or SOCKS5

See Working with Proxies for proxy formats.

Output Settings

Save Working Sessions: Keep validated session files
Check Spam Status: Query @spambot for restrictions
Check Bot Interactions: Scan for crypto/gaming bot activity
Delete Bot Chats: Clean up after extraction

Processing Settings

Worker Threads: 1-50 concurrent workers
Connection Timeout: 5-300 seconds
Max Retries: 0-10 retry attempts

Bots Checked

@spambot: Check spam/restriction status
@cryptobot: Extract wallet balances
Interaction History: Checks for activity with @send, @BTC_CHANGE_BOT, @hamster_kombat_bot, @notcoin_bot, @blum_game_bot, @major_game_bot, @tonxdao_bot, @fragment

Convert Mode

Source/Target

Source Session: Select file or folder based on format
From Format: Tdata, Telethon, or Pyrogram
To Format: Telethon or Pyrogram (Tdata not supported as target)
Target Path: Destination file with auto-generate option

Advanced Options

Telethon Target

Format: SQLite (default) or String Session
Include Entities Table: Preserve cached users/chats
Include Update State: Preserve sync state

Pyrogram Target

Version: 1-5 (version compatibility)

General Options

Preserve Metadata: Keep additional session data
Validate After Conversion: Check converted session
Overwrite Existing: Replace target if exists

📧 Sift

Professional email sorter that validates and categorizes email addresses by provider.

🎯 Overview

Sift processes email lists to validate addresses, verify domains via DNS lookups, and sort emails by their provider. It distinguishes between business and free email providers while handling millions of emails efficiently.

✨ Key Features

Provider Detection: Identifies Gmail, Outlook, Yahoo, and 100+ other providers
DNS Verification: MX and SPF record checking
Business vs Free: Separates corporate from personal emails
CSV Support: Process emails with additional data
High Performance: Multi-threaded processing for large datasets

🚀 Quick Start

Launch Sift from Quantium launcher
Select email list (TXT or CSV)
Configure DNS and filtering options
Start processing

📥 Input Formats

📄 TXT Files

[email protected]
[email protected]
[email protected]

📈 CSV Files

Configurable delimiter (comma, tab, pipe, etc.)
Optional headers for column names
Smart email column detection
Preserves additional data in output

📁 Output Structure

output/
├── gmail.txt              # Gmail addresses
├── outlook.txt            # Microsoft emails
├── yahoo.txt              # Yahoo addresses
├── company_domains.txt    # Business emails
├── others_with_mx.txt     # Valid domains
├── others_without_mx.txt  # No MX records
└── invalid.txt            # Failed validation

💡 Tip: Business emails are automatically separated based on domain analysis!

✨ Features

Email Validation

Address Validation

RFC-compliant email format checking
Invalid character detection
Domain format verification
Optional invalid email saving

DNS Verification

MX Records: Verify mail server existence
SPF Records: Check sender policy (optional)
Caching: Store DNS results for performance
Timeout Control: Configurable DNS query timeout

Provider Detection

Provider Database

Fetched from Quantium server
100+ email providers pre-configured
Wildcard MX pattern matching
Regular updates

Provider Categories

Free Providers: Gmail, Yahoo, Outlook, etc.
Business Domains: Corporate and custom domains
Regional Providers: Country-specific services
Unknown Domains: Valid but unrecognized

Sorting Capabilities

Output Organization

One file per detected provider
Separate business email files
Others with valid MX records
Others without MX records
Invalid addresses (optional)

Filtering Options

Process specific providers only
Exclude certain providers
Business/free separation
MX record filtering

Performance

Multi-threading

Configurable thread count
Parallel DNS lookups
Concurrent file processing
Memory-efficient streaming

DNS Optimization

Result caching with TTL
Batch DNS queries
Connection pooling
Retry on timeout

Large File Handling

Stream processing
Live output flushing
Progress tracking
Memory optimization

CSV Processing

Format Support

Auto-detect email column
Configurable delimiters
Header row handling
Data preservation

Output Options

Maintain CSV structure
Extract emails only
Sort with metadata
Custom column mapping

🌐 Providers

Provider Database

Sift uses a comprehensive database of email providers fetched from Quantium servers. The database is regularly updated to include new providers and patterns.

Major Providers

Global Services

Gmail: gmail.com, googlemail.com
Outlook: outlook.com, hotmail.com, live.com
Yahoo: yahoo.com, ymail.com, rocketmail.com
iCloud: icloud.com, me.com, mac.com
AOL: aol.com, aim.com
ProtonMail: protonmail.com, pm.me

Regional Providers

Mail.ru: mail.ru, inbox.ru, list.ru, bk.ru
GMX: gmx.com, gmx.net, gmx.de
Web.de: web.de
Yandex: yandex.ru, yandex.com
QQ: qq.com, foxmail.com
163: 163.com, 126.com

Provider Detection

MX Pattern Matching

Sift identifies providers by:

Direct domain matching
MX record patterns (e.g., *.google.com for Gmail)
Wildcard subdomain matching
Parent domain detection

Business vs Free

Free Providers: Personal email services
Business Domains: Corporate and custom domains
Hybrid Services: Both free and paid tiers

Custom Domains

Google Workspace

Detected via MX records pointing to:

aspmx.l.google.com
alt[1-4].aspmx.l.google.com

Microsoft 365

Detected via MX records containing:

*.protection.outlook.com
*.mail.protection.outlook.com

Other Business Services

Zoho Mail
FastMail
Rackspace Email
Custom mail servers

Output Files

Provider Files

Each detected provider gets its own output file:

gmail.txt
outlook.txt
yahoo.txt
[provider_name].txt

Special Categories

others_with_mx.txt: Valid domains not in database
others_without_mx.txt: No mail server found
business_domains.txt: All corporate emails (optional)

⚙️ Configuration

File Selection

Input

Input File: TXT or CSV email list
Output Directory: Auto-generated with timestamp

Provider Selection

Provider Categories

All Providers: Process every detected provider
Business Providers: Corporate email domains only
Free Providers: Personal email services only
Select specific providers from the list

DNS Validation

Settings

Validate MX Records: Verify mail server existence (default: true)
Check SPF Records: Verify sender policy framework (default: false)

Performance

Threading

Thread Count: 1-100 concurrent workers (default: 10)
Recommended: 10-20 for most systems
Higher values use more resources

Output Options

Save Settings

Separate Business/Free Emails: Split by provider type (default: true)
Save Invalid Emails: Keep malformed addresses (default: true)
Save Others with MX: Unknown domains with valid MX (default: true)
Save Others without MX: Domains without mail servers (default: true)

CSV Options

Format Settings

First Row Contains Headers: Skip header row (default: true)
Column Delimiter: Comma, Semicolon, Tab, or Pipe (default: comma)

Output Structure

Sift creates these output files based on settings:

{provider}.txt - One file per selected provider
business_providers.txt - All business emails (if separation enabled)
free_providers.txt - All free email providers (if separation enabled)
others_with_mx.txt - Unknown domains with valid MX records
others_without_mx.txt - Domains without MX records
invalid.txt - Malformed email addresses

📄 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

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
Concurrent connections
Per-provider proxy assignment

Telegram Tools (Teletools)

Sticky proxies per session
Protocol override options
Connection persistence

Web Tools (Hydros, Vanadum)

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

Keyboard shortcuts

Quantium Documentation