Temp Mail API · Rust

Temp Mail
in Rust.

Wegwerf-Postfächer und OTP-Extraktion für Rust — reines HTTP, kein SDK.

verify.rs

use serde_json::{json, Value};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("EVILMAIL_KEY")?;
    let res: Value = reqwest::blocking::Client::new()
        .post("https://evilmail.pro/api/temp-email")
        .header("X-API-Key", key)
        .json(&json!({ "ttlMinutes": 30 }))
        .send()?
        .json()?;
    let email = res["data"]["email"].as_str().unwrap_or("");
    println!("Inbox: {email}");
    Ok(())
}

Ein Rust-Temp-Mail-Postfach hochzufahren, ermöglicht dir das Testen von Anmeldeabläufen, E-Mail-Verifizierung und OTP-Zustellung ganz ohne echtes Postfach oder ein instabiles geteiltes Konto. EvilMail stellt eine reine HTTP-API bereit: Erstelle ein Wegwerf-Postfach, frage es auf eingehende Mails ab und ziehe den Bestätigungscode direkt in deine Integrationstests oder CI-Pipeline. Es gibt keinen SMTP-Server zu betreiben und kein SDK einzubinden — nur reqwest, serde_json und einen API-Key aus einer Umgebungsvariablen.

§ 01

Warum Temp Mail in Rust nutzen

End-to-End-Anmeldetests

Registriere ein echtes Konto in deiner Staging-Umgebung mit einer frischen Wegwerf-E-Mail und prüfe dann, ob die Willkommens- oder Verifizierungsnachricht tatsächlich ankommt. Kein geteiltes Postfach, das zwischen den Durchläufen aufgeräumt werden muss.

OTP- & 2FA-Automatisierung

Warte auf die Login- oder Verifizierungs-E-Mail, extrahiere den sechsstelligen Code per Regex aus dem Text und speise ihn zurück in deinen Ablauf. Ideal zum Testen passwortloser und Zwei-Faktor-Logins in Rust.

E-Mail-Prüfungen in der CI-Pipeline

Lies den API-Key aus einer Umgebungsvariablen und führe den kompletten Erstellen-Abfragen-Lesen-Zyklus in GitHub Actions oder GitLab CI aus. Jeder Build bekommt ein sauberes, isoliertes Postfach.

Bestätigungslinks auslesen

Hole Aktivierungs-URLs oder Magic Links aus dem Nachrichtentext oder HTML, folge ihnen mit reqwest und prüfe, ob der gesamte Onboarding-Pfad ohne menschliches Zutun funktioniert.

§ 02

Der Ablauf — Rust Temp Mail in 3 Aufrufen

Wegwerf-Postfach erstellen

verify.rs

use serde_json::{json, Value};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let key = std::env::var("EVILMAIL_KEY")?;
    let client = reqwest::blocking::Client::new();

    // Ask EvilMail for a fresh inbox that lives 30 minutes.
    let res: Value = client
        .post("https://evilmail.pro/api/temp-email")
        .header("X-API-Key", &key)
        .json(&json!({ "ttlMinutes": 30 }))
        .send()?
        .json()?;

    let email = res["data"]["email"].as_str().unwrap_or("");
    let token = res["data"]["sessionToken"].as_str().unwrap_or("");
    println!("Inbox {email} ready (token {token})");
    Ok(())
}

Abfragen, bis die E-Mail ankommt

verify.rs

use serde_json::Value;
use std::{thread::sleep, time::Duration};

// Poll the session ~20 times, 3s apart, until mail lands.
fn wait_for_message(
    client: &reqwest::blocking::Client,
    key: &str,
    token: &str,
) -> Result<u64, Box<dyn std::error::Error>> {
    let url =
        format!("https://evilmail.pro/api/temp-email/{token}");

    for _ in 0..20 {
        let res: Value = client
            .get(&url)
            .header("X-API-Key", key)
            .send()?
            .json()?;

        // messages is empty until something is delivered.
        if let Some(msg) = res["data"]["messages"].get(0) {
            let uid = msg["uid"].as_u64().unwrap_or(0);
            let subject = msg["subject"].as_str().unwrap_or("");
            println!("Got mail: {subject} (uid {uid})");
            return Ok(uid);
        }
        sleep(Duration::from_secs(3));
    }
    Err("timed out waiting for email".into())
}

Nachricht lesen & Code extrahieren

verify.rs

use regex::Regex;
use serde_json::Value;

// Fetch the message body and pull out a 6-digit OTP.
fn extract_code(
    client: &reqwest::blocking::Client,
    key: &str,
    token: &str,
    uid: u64,
) -> Result<Option<String>, Box<dyn std::error::Error>> {
    let url = format!(
        "https://evilmail.pro/api/message/{uid}?token={token}"
    );
    let res: Value = client
        .get(&url)
        .header("X-API-Key", key)
        .send()?
        .json()?;

    let body = res["data"]["text"].as_str().unwrap_or("");

    // A one-time code is six consecutive digits.
    let re = Regex::new(r"\b(\d{6})\b")?;
    let code = re.captures(body).map(|c| c[1].to_string());

    match &code {
        Some(c) => println!("OTP = {c}"),
        None => println!("No 6-digit code found"),
    }
    Ok(code)
}

§ 03

Rust Temp Mail — FAQ

Q1Wie bekomme ich eine Temp-Mail-Adresse in Rust?−

Sende ein POST an https://evilmail.pro/api/temp-email mit deinem X-API-Key-Header und einem JSON-Body wie {"ttlMinutes": 30}. Die Antwort enthält data.email (die Wegwerf-Adresse) und data.sessionToken, mit dem du Nachrichten abfragst und liest. Siehe das Hero-Snippet — es sind etwa zehn Zeilen mit reqwest und serde_json.

Q2Kann ich das für automatisierte Tests verwenden?+

Ja — das ist der primäre Anwendungsfall. Lies den API-Key aus einer Umgebungsvariablen, erzeuge pro Test ein frisches Postfach und führe den Erstellen-Abfragen-Lesen-Zyklus in deiner Integrationssuite oder CI aus. Da jedes Postfach isoliert und kurzlebig ist, beeinflussen sich Tests nicht gegenseitig und es gibt nichts aufzuräumen.

Q3Wie extrahiere ich das OTP?+

Rufe GET /api/message/{uid}?token={sessionToken} auf, um die Nachricht abzurufen, und führe dann einen Regex über data.text (oder data.html) aus. Für einen standardmäßigen sechsstelligen Einmalcode funktioniert das Muster \b(\d{6})\b; Capture-Gruppe 1 ist der Code. Das Snippet aus Schritt 3 zeigt dies mit dem regex-Crate.

Q4Brauche ich einen API-Key / gibt es Rate-Limits?+

Ja, jede Anfrage benötigt den X-API-Key-Header — halte den Key in einer Umgebungsvariablen wie EVILMAIL_KEY, statt ihn fest einzucodieren. Anfragen sind pro Key rate-limitiert, halte dich beim Abfragen also an ein sinnvolles Intervall (die Beispiele verwenden 3 Sekunden zwischen den ~20 Abfrageversuchen), statt in einer engen Schleife zu pollen.

Q5Wie lange lebt das Postfach?+

Du steuerst es beim Erstellen des Postfachs über das Feld ttlMinutes — die Beispiele verwenden 30 Minuten. Sobald die TTL abläuft, werden die Adresse und ihre Nachrichten verworfen, frage die Nachricht also innerhalb dieses Zeitfensters ab und lies sie. Für die meisten Verifizierungs- und OTP-Abläufe reicht eine kurze TTL von 10 bis 30 Minuten völlig aus.

§ 04

Temp Mail in anderen Sprachen

NNode.js→PPython→GGo→PPHP→JJava→CC#→RRuby→ccURL→

§ Loslegen

Ein API-Schlüssel. Wegwerf-Postfächer im großen Stil.

Erstelle unbegrenzt Wegwerf-Adressen, frage sie per HTTP ab und zieh Bestätigungscodes direkt in deine Tests und CI. Kostenlos zum Start; Custom-Domains und höhere Limits in den kostenpflichtigen Tarifen.

API-Dokumentation lesen Tarife ansehen →

use serde_json::{json, Value}; fn main() -> Result<(), Box<dyn std::error::Error>> { let key = std::env::var("EVILMAIL_KEY")?; let res: Value = reqwest::blocking::Client::new() .post("https://evilmail.pro/api/temp-email") .header("X-API-Key", key) .json(&json!({ "ttlMinutes": 30 })) .send()? .json()?; let email = res["data"]["email"].as_str().unwrap_or(""); println!("Inbox: {email}"); Ok(()) }

use serde_json::{json, Value}; fn main() -> Result<(), Box<dyn std::error::Error>> { let key = std::env::var("EVILMAIL_KEY")?; let client = reqwest::blocking::Client::new(); // Ask EvilMail for a fresh inbox that lives 30 minutes. let res: Value = client .post("https://evilmail.pro/api/temp-email") .header("X-API-Key", &key) .json(&json!({ "ttlMinutes": 30 })) .send()? .json()?; let email = res["data"]["email"].as_str().unwrap_or(""); let token = res["data"]["sessionToken"].as_str().unwrap_or(""); println!("Inbox {email} ready (token {token})"); Ok(()) }

use serde_json::Value; use std::{thread::sleep, time::Duration}; // Poll the session ~20 times, 3s apart, until mail lands. fn wait_for_message( client: &reqwest::blocking::Client, key: &str, token: &str, ) -> Result<u64, Box<dyn std::error::Error>> { let url = format!("https://evilmail.pro/api/temp-email/{token}"); for _ in 0..20 { let res: Value = client .get(&url) .header("X-API-Key", key) .send()? .json()?; // messages is empty until something is delivered. if let Some(msg) = res["data"]["messages"].get(0) { let uid = msg["uid"].as_u64().unwrap_or(0); let subject = msg["subject"].as_str().unwrap_or(""); println!("Got mail: {subject} (uid {uid})"); return Ok(uid); } sleep(Duration::from_secs(3)); } Err("timed out waiting for email".into()) }

use regex::Regex; use serde_json::Value; // Fetch the message body and pull out a 6-digit OTP. fn extract_code( client: &reqwest::blocking::Client, key: &str, token: &str, uid: u64, ) -> Result<Option<String>, Box<dyn std::error::Error>> { let url = format!( "https://evilmail.pro/api/message/{uid}?token={token}" ); let res: Value = client .get(&url) .header("X-API-Key", key) .send()? .json()?; let body = res["data"]["text"].as_str().unwrap_or(""); // A one-time code is six consecutive digits. let re = Regex::new(r"\b(\d{6})\b")?; let code = re.captures(body).map(|c| c[1].to_string()); match &code { Some(c) => println!("OTP = {c}"), None => println!("No 6-digit code found"), } Ok(code) }