Temp Mail API · Java

Temp Mail
in Java.

Wegwerf-E-Mail-Postfächer in Java, mit einem einzigen HTTP-Aufruf.

VerifyTest.java

var http = HttpClient.newHttpClient();
var req = HttpRequest.newBuilder()
    .uri(URI.create("https://evilmail.pro/api/temp-email"))
    .header("X-API-Key", System.getenv("EVILMAIL_KEY"))
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"ttlMinutes\":30}"))
    .build();
var body = http.send(req, HttpResponse.BodyHandlers.ofString()).body();
// body -> {"data":{"email":"...","sessionToken":"..."}}
var email = body.replaceAll("(?s).*\"email\":\"([^\"]+)\".*", "$1");
System.out.println("Inbox: " + email);

Ein Java-Temp-Mail-Postfach zu erzeugen bedeutete früher, eine Web-UI zu scrapen oder einen eigenen SMTP-Catch-all aufzusetzen — mit EvilMail ist es eine einzige HTTP-Anfrage. Diese Seite zeigt Temp Mail in Java mit nichts als dem eingebauten java.net.http.HttpClient: ein Wegwerf-Postfach anlegen, es abfragen, bis eine Bestätigungs-E-Mail eintrifft, dann die Nachricht lesen und das OTP herausziehen. Genau das brauchst du, um E-Mail-Verifizierungstests in der CI zu automatisieren, Anmeldeabläufe End-to-End durchzuspielen oder Passwort-Reset-Codes zu prüfen, ohne je ein echtes Postfach anzufassen. Kein SDK, keine Abhängigkeiten — nur die Temp-Mail-API und schlichtes HTTP, das du in jede JUnit- oder Integrations-Suite einfügen kannst.

§ 01

Warum Temp Mail in Java nutzen

End-to-End-Anmeldetests

Lege pro Testlauf ein frisches Wegwerf-Postfach an, damit sich Registrierungsabläufe nie in die Quere kommen. Prüfe, dass die Willkommens- oder Bestätigungs-E-Mail tatsächlich ankommt, bevor du weitermachst.

OTP- & Verifizierungscodes in der CI

Frage das Postfach aus deiner JUnit- oder Integrations-Suite ab und ziehe den 6-stelligen Code per Regex direkt aus dem Text. Java-E-Mail-Verifizierungstests werden vollständig headless und wiederholbar.

Passwort-Reset-QA

Löse einen Reset aus, hole die temporäre E-Mail in Java und folge dem tokenisierten Link — so validierst du den gesamten Ablauf ohne ein geteiltes Team-Postfach, das sich mit Test-Rauschen füllt.

Wegwerf-Postfächer für Scraper & Bots

Wenn ein Workflow eine Wegwerfadresse braucht, erzeuge sie bei Bedarf mit kurzer TTL. Das Postfach läuft von selbst ab, sodass danach nichts aufzuräumen ist.

§ 02

Der Ablauf — Java Temp Mail in 3 Aufrufen

Ein Wegwerf-Postfach anlegen

VerifyTest.java

import java.net.URI;
import java.net.http.*;

var http = HttpClient.newHttpClient();
var key  = System.getenv("EVILMAIL_KEY"); // never hard-code

var create = HttpRequest.newBuilder()
    .uri(URI.create("https://evilmail.pro/api/temp-email"))
    .header("X-API-Key", key)
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString("{\"ttlMinutes\":30}"))
    .build();

var body = http.send(create,
    HttpResponse.BodyHandlers.ofString()).body();
// {"data":{"email":"..","sessionToken":".."}}
var email = body.replaceAll("(?s).*\"email\":\"([^\"]+)\".*", "$1");
var token = body.replaceAll(
    "(?s).*\"sessionToken\":\"([^\"]+)\".*", "$1");
System.out.println("Inbox " + email + " (token " + token + ")");

Abfragen, bis die E-Mail eintrifft

VerifyTest.java

import java.util.regex.Pattern;

// Poll up to 20 times, 3s apart, until a message lands.
int uid = -1;
for (int i = 0; i < 20 && uid < 0; i++) {
    var poll = HttpRequest.newBuilder()
        .uri(URI.create(
            "https://evilmail.pro/api/temp-email/" + token))
        .header("X-API-Key", key)
        .build();
    var body = http.send(poll,
        HttpResponse.BodyHandlers.ofString()).body();

    // messages[] carries a "uid" once mail arrives
    var m = Pattern.compile("\"uid\":(\\d+)").matcher(body);
    if (m.find()) {          // first (newest) message
        uid = Integer.parseInt(m.group(1));
        break;
    }
    Thread.sleep(3000);      // wait before the next attempt
}
if (uid < 0) throw new RuntimeException("No mail after ~60s");
System.out.println("Got message uid=" + uid);

Die Nachricht lesen & den Code extrahieren

VerifyTest.java

import java.util.regex.Pattern;

var read = HttpRequest.newBuilder()
    .uri(URI.create("https://evilmail.pro/api/message/" + uid
        + "?token=" + token))
    .header("X-API-Key", key)
    .build();

var body = http.send(read,
    HttpResponse.BodyHandlers.ofString()).body();
// data.text holds the plain-text body
var text = body.replaceAll(
    "(?s).*\"text\":\"([^\"]*)\".*", "$1");

// A 6-digit OTP:  \b(\d{6})\b
var otp = Pattern.compile("\\b(\\d{6})\\b").matcher(text);
if (otp.find()) System.out.println("Code: " + otp.group(1));
else            System.out.println("No 6-digit code found");

§ 03

Java Temp Mail — FAQ

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

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 liefert data.email (die Adresse) und data.sessionToken, den du behältst, um Nachrichten abzufragen und zu lesen. Das Hero-Snippet oben macht genau das mit dem eingebauten java.net.http.HttpClient — kein externes SDK nötig.

Q2Kann ich das für automatisierte Tests nutzen?+

Ja, das ist der Hauptanwendungsfall. Da alles schlichtes HTTP ist, kannst du zu Beginn eines JUnit- oder Integrationstests ein Postfach anlegen, die E-Mail deiner App auslösen, abfragen, bis sie ankommt, und ihren Inhalt prüfen. Gib jedem Testlauf sein eigenes Postfach, damit parallele Läufe nie denselben Zustand teilen, und nutze eine kurze TTL, damit zwischen den Builds nichts hängen bleibt.

Q3Wie extrahiere ich das OTP?+

Hole die Nachricht per GET /api/message/{uid}?token={sessionToken} und wende dann eine Regex auf data.text (oder data.html) an. Ein Standard-6-stelliger Code passt auf \b(\d{6})\b. Der Extract-Schritt oben kompiliert dieses Muster und gibt den ersten Treffer aus — tausche dein eigenes Muster für Links oder anders formatierte Codes ein.

Q4Brauche ich einen API-Schlüssel / gibt es Rate-Limits?+

Ja, jede Anfrage muss einen X-API-Key-Header senden; lies ihn aus einer Umgebungsvariable wie EVILMAIL_KEY, statt ihn fest zu codieren. Anfragen sind pro Schlüssel rate-limitiert, füge also eine kleine Pause zwischen den Abfragen ein (das Beispiel wartet 3 Sekunden), anstatt den Endpunkt in einer engen Schleife zu bombardieren.

Q5Wie lange lebt das Postfach?+

Du steuerst das mit dem Feld ttlMinutes, wenn du das Postfach anlegst — in diesen Beispielen 30 Minuten. Sobald die TTL abläuft, verfallen die Adresse und ihre Nachrichten automatisch, sodass sich Wegwerf-Postfächer selbst aufräumen und nach einem Testlauf nichts abzubauen ist.

§ 04

Temp Mail in anderen Sprachen

NNode.js→PPython→GGo→PPHP→RRust→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 →

import java.net.URI; import java.net.http.*; var http = HttpClient.newHttpClient(); var key = System.getenv("EVILMAIL_KEY"); // never hard-code var create = HttpRequest.newBuilder() .uri(URI.create("https://evilmail.pro/api/temp-email")) .header("X-API-Key", key) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString("{\"ttlMinutes\":30}")) .build(); var body = http.send(create, HttpResponse.BodyHandlers.ofString()).body(); // {"data":{"email":"..","sessionToken":".."}} var email = body.replaceAll("(?s).*\"email\":\"([^\"]+)\".*", "$1"); var token = body.replaceAll( "(?s).*\"sessionToken\":\"([^\"]+)\".*", "$1"); System.out.println("Inbox " + email + " (token " + token + ")");

import java.util.regex.Pattern; // Poll up to 20 times, 3s apart, until a message lands. int uid = -1; for (int i = 0; i < 20 && uid < 0; i++) { var poll = HttpRequest.newBuilder() .uri(URI.create( "https://evilmail.pro/api/temp-email/" + token)) .header("X-API-Key", key) .build(); var body = http.send(poll, HttpResponse.BodyHandlers.ofString()).body(); // messages[] carries a "uid" once mail arrives var m = Pattern.compile("\"uid\":(\\d+)").matcher(body); if (m.find()) { // first (newest) message uid = Integer.parseInt(m.group(1)); break; } Thread.sleep(3000); // wait before the next attempt } if (uid < 0) throw new RuntimeException("No mail after ~60s"); System.out.println("Got message uid=" + uid);

import java.util.regex.Pattern; var read = HttpRequest.newBuilder() .uri(URI.create("https://evilmail.pro/api/message/" + uid + "?token=" + token)) .header("X-API-Key", key) .build(); var body = http.send(read, HttpResponse.BodyHandlers.ofString()).body(); // data.text holds the plain-text body var text = body.replaceAll( "(?s).*\"text\":\"([^\"]*)\".*", "$1"); // A 6-digit OTP: \b(\d{6})\b var otp = Pattern.compile("\\b(\\d{6})\\b").matcher(text); if (otp.find()) System.out.println("Code: " + otp.group(1)); else System.out.println("No 6-digit code found");