Multi-Engine Validation

Email Validation API

A high-intelligence, multi-engine email validation service built with FastAPI. Orchestrates deep SMTP checks, heuristic pre-filtering, and reputation analysis to deliver verifiable, consensus-based deliverability verdicts.

Try It Live API Reference

POST /api/v1/verify-email

Port 1098 FastAPI + DuckDB LightGBM ML

0 Interactive Dashboard

Validate emails, manage allow/block lists, tune scoring rules, and monitor service health — all from one dashboard.

Validation Workbench

Test emails, tune scoring, and manage domain rules from one page.

This dashboard is wired to the Laravel Mail Validation API and exposes the live validation, feedback, list, scoring, root, and health endpoints.

API base

https://validation.laravelmail.com

Handshake

Loading API root response...

Health

Checking service...

Service Status

`/health` is polled every 30 seconds so this page surfaces reachability problems without a refresh.

{
  "status": "loading"
}

Email validation

Submit an address to `POST /v1/filter-email`. Valid inputs also auto-run after a short debounce.

`FilterEmailResponse`

Run a validation to inspect verdict, score, MX records, and risk flags.

Lists

Manage allow and block rules with `GET`, `POST`, and `DELETE` calls under `/v1/lists`.

Whitelist

Current size: 0

No domains in this list.

Blacklist

Current size: 0

No domains in this list.

Disposable

Read-only view from `GET /v1/lists`.

No items in this list.

Spam Keywords

Read-only view from `GET /v1/lists`.

No items in this list.

Scoring

Edit the values returned by `GET /v1/scores` and persist them with `POST /v1/scores`.

Restart required after save

Loading scoring configuration...

1 What You Get

A unified email validation service combining multiple verification engines, Bayesian inference, and LightGBM machine learning — all running on your own infrastructure.

Unified API

Single endpoint for all verification needs. No need to orchestrate multiple services — one call returns a comprehensive verdict.

Multi-Engine Pipeline

Bloombox, syntax, MX/DNS, disposable detection, SMTP verification, Bayesian inference, and LightGBM ML — all working in concert.

ML-Powered Intelligence

LightGBM model trained on actual verification data stored in DuckDB. Continuously improving with live telemetry feedback loops.

2 Architecture

The service is fully unified into a single FastAPI backend. The legacy EmailFilter service has been decommissioned and its logic integrated into the core pipeline.

Port

1098

FastAPI backend

Database

DuckDB

data/email_validation.db

Model

LightGBM

/app/model.txt

3 Verification Engines

Each email passes through multiple specialized engines. Signals are combined using weighted scoring and machine learning to produce a final verdict.

Bloombox

<1ms

High-speed Bloom filter checks across 1M+ known disposable and invalid domains. Sub-millisecond lookups for instant pre-filtering.

Syntax Validator

<1ms

RFC-compliant email syntax validation. Catches malformed addresses before they reach heavier verification stages.

MX/DNS Checker

~10ms

Real-time mail exchanger verification. Confirms the domain has valid MX records and can accept email.

Disposable Detector

<1ms

Identifies temporary and throwaway email providers using an ever-growing database of disposable email services.

Reacher SMTP

~1.2s

Deep SMTP verification that connects to the mail server to confirm mailbox existence without sending an email.

Bayesian Inference

<5ms

Statistical probability engine that combines all signal weights to produce a unified confidence score for each validation.

LightGBM ML

~10ms

Machine learning model trained on real verification data. Provides nuanced deliverability predictions beyond rule-based systems.

4 Quick Start

Validate your first email with a single API call. The service runs on port 1098 and returns a comprehensive verdict with confidence scores.

Validation Request

curl -X POST "http://localhost:1098/api/v1/verify-email" \
     -H "Content-Type: application/json" \
     -d '{"email": "test@example.com"}'

200 OK

Response

{
  "email": "user@gmail.com",
  "verdict": {
    "status": "safe",
    "confidence": 0.95,
    "score": 0.98,
    "source": "hybrid_ml",
    "recommendation": "accept",
    "reasons": ["Mailbox exists", "High-trust domain age"],
    "audit_log": [
      { "signal": "deliverable", "value": true, "weight": 1.4, "contribution": 0.35 }
    ]
  },
  "engines": {
    "reacher": { "status": "success", "latency_ms": 1200 },
    "emailfilter": { "status": "success", "latency_ms": 150 },
    "bloombox": { "status": "success", "latency_ms": 10 }
  },
  "meta": { "request_id": "req_abc123...", "processing_time_ms": 1360 }
}

5 API Reference

Verify Email

POST /api/v1/verify-email

Request Body

{
  "email": "user@gmail.com",
  "is_signup": true,
  "proxy": {
    "host": "your-proxy.com",
    "port": 1080
  }
}

required — Email address to validate

is_signup

optional — Hint for signup context

proxy

optional — SMTP proxy configuration

Verdict Fields

Field	Type	Description
`status`	`string`	safe, risky, or invalid
`confidence`	`float`	0.0 – 1.0 confidence level
`score`	`float`	Composite deliverability score
`source`	`string`	hybrid_ml, rule_based, or ml_only
`recommendation`	`string`	accept, review, or reject
`reasons`	`string[]`	Human-readable explanation list
`audit_log`	`array`	Signal-by-signal contribution breakdown

6 Machine Learning Pipeline

The validation engine improves over time using telemetry data stored in DuckDB. Train the model with live data and bootstrap high-quality samples for cold starts.

ML Training

Train the model using live telemetry data stored in DuckDB:

make train

Data Bootstrapping

Seed the database with high-quality verification samples:

make bootstrap

7 Accessing Telemetry

The system creates a DuckDB database at data/email_validation.db. Export verified leads directly via the service API.

Python Export

from app.services.database import EmailValidationDB

db = EmailValidationDB("data/email_validation.db")
db.export_valid_emails("verified_leads.csv")

8 Configuration

Configure the service using environment variables. Most have sensible defaults and work out of the box.

Variable	Default	Description
`EMAILFILTER_URL`	`http://localhost:1099`	Internal EmailFilter endpoint
`REACHER_TIMEOUT_SECONDS`	`30`	Max wait for Rust SMTP engine
`RATE_LIMIT_REQUESTS`	`10`	Num requests in window
`RATE_LIMIT_WINDOW_SECONDS`	`60`	Window size for throttling
`PERSIST_TO_DB`	`true`	Save to DuckDB
`LOG_EMAIL_ADDRESSES`	`false`	Redact PI in text logs