Verify emails in Rust with Verifly

Email verification in Rust

Rust makes it easy to write a fast, correct email service, but the language cannot tell you whether a mailbox on the far side of the internet is real. Crates that parse and validate address syntax, or a hand-rolled check, only confirm that user@dead-domain.com is well-formed. Whether that address accepts mail is a runtime fact that lives behind an SMTP handshake, and Verifly performs that handshake for you over one HTTPS request.

Because Verifly is a plain REST API, you reach for the crates you already have: reqwest for the async HTTP call and serde for zero-boilerplate deserialization into a typed struct. You send a GET to /api/v1/verify with bearer_auth, and .json() gives you back a Verdict with a result field of deliverable, undeliverable, or risky plus boolean flags for disposable, role, catch_all, and smtp. Because it is strongly typed, the compiler holds you to handling the shape you declared.

The pay-as-you-go model fits both a long-lived Tokio service and a short CLI. Grab a key, spend credits from $2 per 1,000 checks down to $0.60 per 1,000 at volume, and the same key works from an Axum server, a Lambda built on the Rust runtime, or a local binary. Self-register for 100 free credits with no card at the autonomous register endpoint.

Batch-verify a list of emails in Rust

When you hold more than a handful of addresses, do not loop the single endpoint — POST them together to /api/v1/verify/batch. It takes a JSON body with an emails array and returns a results array in the same order, which deserializes cleanly into a Vec of typed structs. Serialize your request with a serde_json::json! macro and let serde do the rest on the way back.

use serde::Deserialize;
use serde_json::json;

#[derive(Deserialize)]
struct Item {
    email: String,
    result: String,
    #[serde(default)]
    disposable: bool,
    #[serde(default)]
    role: bool,
}

#[derive(Deserialize)]
struct Batch {
    results: Vec<Item>,
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = reqwest::Client::new();
    let emails = ["ada@example.com", "info@acme.com", "noreply@disposable.tld"];

    let batch: Batch = client
        .post("https://verifly.email/api/v1/verify/batch")
        .bearer_auth("vf_YOUR_KEY")
        .json(&json!({ "emails": emails }))
        .send()
        .await?
        .json()
        .await?;

    let keep: Vec<&str> = batch
        .results
        .iter()
        .filter(|r| r.result == "deliverable" && !r.disposable && !r.role)
        .map(|r| r.email.as_str())
        .collect();

    println!("Keeping {} of {} addresses", keep.len(), batch.results.len());
    Ok(())
}

Wire it into an Axum signup handler

The most valuable place to verify in Rust is the moment a user registers. Share a reqwest::Client through your Axum or Actix application state, call Verifly with a short timeout, and reject disposable addresses before writing the account. Match on the Result so a network error returns a fail-open path rather than a 500 that blocks a legitimate signup.

use axum::{http::StatusCode, Json};
use serde::Deserialize;
use std::time::Duration;

#[derive(Deserialize)]
struct Signup {
    email: String,
}

#[derive(Deserialize)]
struct Verdict {
    result: String,
    disposable: bool,
}

async fn register(Json(body): Json<Signup>) -> Result<StatusCode, StatusCode> {
    let client = reqwest::Client::builder()
        .timeout(Duration::from_secs(8))
        .build()
        .unwrap();

    match client
        .get("https://verifly.email/api/v1/verify")
        .query(&[("email", &body.email)])
        .bearer_auth("vf_YOUR_KEY")
        .send()
        .await
    {
        Ok(resp) => {
            let v: Verdict = resp.json().await.map_err(|_| StatusCode::BAD_GATEWAY)?;
            if v.disposable || v.result == "undeliverable" {
                return Err(StatusCode::BAD_REQUEST);
            }
        }
        Err(_) => { /* fail open: never block signup on a network error */ }
    }

    // create_user(&body.email).await;
    Ok(StatusCode::CREATED)
}