Temp Mail
in Go.
Wegwerf-E-Mail für Go, nur einen HTTP-Aufruf entfernt.
package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
"os"
)
func main() {
req, _ := http.NewRequest("POST",
"https://evilmail.pro/api/temp-email",
bytes.NewBufferString(`{"ttlMinutes": 30}`))
req.Header.Set("X-API-Key", os.Getenv("EVILMAIL_KEY"))
req.Header.Set("Content-Type", "application/json")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
var r struct {
Data struct {
Email string `json:"email"`
SessionToken string `json:"sessionToken"`
} `json:"data"`
}
json.NewDecoder(resp.Body).Decode(&r)
fmt.Println("Inbox ready:", r.Data.Email)
}Richte temporäre Postfächer in Go mit wenigen Zeilen ein: Die Wegwerf-E-Mail-API von EvilMail lässt dich Einweg-Postfächer erstellen, eingehende Nachrichten abrufen und OTP-Codes direkt aus deiner Testsuite oder CI-Pipeline extrahieren. Statt ein echtes Postfach zu betreuen oder eine Web-Oberfläche zu scrapen, sprichst du einfache HTTP-Endpunkte mit net/http an und dekodierst das JSON — kein Drittanbieter-SDK, kein Headless-Browser. Entwickelt für Go-E-Mail-Verifizierungstests, Smoke-Tests von Registrierungsabläufen und jeden Workflow, in dem du bei Bedarf eine echte, empfangsbereite Adresse brauchst.
Warum Temp Mail in Go nutzen
Automatisierte Registrierungstests
Registriere für jeden End-to-End-Testlauf eine frische Wegwerf-E-Mail in Go, damit sich Konten nie überschneiden. Jedes Postfach ist echt und empfangsbereit, sodass sich dein Registrierungsablauf genau so verhält wie in der Produktion.
OTP und E-Mail-Verifizierung
Rufe das Postfach ab, schnapp dir die Bestätigungsmail und extrahiere den 6-stelligen Code per Regex — alles in einer einzigen Go-Routine. Perfekt zum Testen von Verifizierungs- und Zwei-Faktor-Abläufen ohne menschliches Zutun.
CI/CD-Pipelines
Da es nur net/http und einen API-Key aus einer Umgebungsvariable braucht, läuft derselbe Code lokal und in GitHub Actions oder GitLab CI. Kein SMTP-Server, keine Postfach-Zugangsdaten zum Rotieren.
Last- und Multi-Account-Tests
Erstelle mit Goroutines viele unabhängige Postfächer gleichzeitig, um Hunderte von Nutzern zu simulieren, die sich zeitgleich registrieren. Jeder Session-Token isoliert ein Postfach, sodass parallele Tests sauber bleiben.
Der Ablauf — Go Temp Mail in 3 Aufrufen
Ein Wegwerf-Postfach erstellen
// createInbox spins up a disposable EvilMail inbox and
// returns its address plus the session token used to poll it.
func createInbox(key string) (email, token string, err error) {
body := bytes.NewBufferString(`{"ttlMinutes": 30}`)
req, err := http.NewRequest("POST",
"https://evilmail.pro/api/temp-email", body)
if err != nil {
return "", "", err
}
req.Header.Set("X-API-Key", key)
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
return "", "", err
}
defer resp.Body.Close()
var r struct {
Data struct {
Email string `json:"email"`
SessionToken string `json:"sessionToken"`
} `json:"data"`
}
if err := json.NewDecoder(resp.Body).Decode(&r); err != nil {
return "", "", err
}
return r.Data.Email, r.Data.SessionToken, nil
}Abrufen, bis die E-Mail eintrifft
// Message mirrors one row from the inbox listing.
type Message struct {
UID int `json:"uid"`
From string `json:"from"`
Subject string `json:"subject"`
}
// waitForMessage polls the inbox ~20 times, 3s apart, until at
// least one message lands, then returns the first one.
func waitForMessage(key, token string) (Message, error) {
url := "https://evilmail.pro/api/temp-email/" + token
for i := 0; i < 20; i++ {
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("X-API-Key", key)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return Message{}, err
}
var r struct {
Data struct {
Messages []Message `json:"messages"`
} `json:"data"`
}
json.NewDecoder(resp.Body).Decode(&r)
resp.Body.Close()
if len(r.Data.Messages) > 0 {
return r.Data.Messages[0], nil
}
time.Sleep(3 * time.Second) // wait, then retry
}
return Message{}, fmt.Errorf("timed out waiting for email")
}Nachricht lesen & Code extrahieren
// otpRe matches a standalone 6-digit verification code.
var otpRe = regexp.MustCompile(`\b(\d{6})\b`)
// readCode fetches a message body and pulls the 6-digit OTP.
func readCode(key, token string, uid int) (string, error) {
url := fmt.Sprintf(
"https://evilmail.pro/api/message/%d?token=%s", uid, token)
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("X-API-Key", key)
resp, err := http.DefaultClient.Do(req)
if err != nil {
return "", err
}
defer resp.Body.Close()
var r struct {
Data struct {
Text string `json:"text"`
HTML string `json:"html"`
} `json:"data"`
}
json.NewDecoder(resp.Body).Decode(&r)
// Regex over the plain-text body (fall back to HTML).
m := otpRe.FindStringSubmatch(r.Data.Text)
if m == nil {
return "", fmt.Errorf("no 6-digit code found")
}
return m[1], nil
}Go Temp Mail — FAQ
Q1Wie erhalte ich eine temporäre E-Mail-Adresse in Go?−
Sende eine POST-Anfrage 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 Adresse) und data.sessionToken (zum Abrufen dieses Postfachs). Die oben gezeigte createInbox-Funktion macht genau das mit net/http und encoding/json — kein SDK erforderlich.
Q2Kann ich das für automatisierte Tests verwenden?+
Ja, das ist der primäre Anwendungsfall. Der gesamte Ablauf ist reines HTTP, sodass er sich direkt in Go-Testdateien, CI-Jobs oder Last-Skripte einfügen lässt. Lies den API-Key aus einer Umgebungsvariable wie EVILMAIL_KEY, erstelle pro Test ein Postfach und lass es nach Ablauf der TTL verfallen. Mit Goroutines kannst du für parallele Tests viele Postfächer gleichzeitig erstellen.
Q3Wie extrahiere ich den OTP aus einer E-Mail?+
Nachdem das Abrufen eine Nachricht zurückgegeben hat, hole ihren Inhalt per GET https://evilmail.pro/api/message/{uid}?token={sessionToken}. Führe dann eine regexp über data.text (oder data.html) aus. Ein alleinstehender 6-stelliger Code passt auf das Muster \b(\d{6})\b — kompiliere es einmal mit regexp.MustCompile und verwende FindStringSubmatch, um die Ziffern zu erfassen, wie in readCode gezeigt.
Q4Brauche ich einen API-Key und gibt es Rate-Limits?+
Ja — jede Anfrage muss deinen Key im X-API-Key-Header senden, und auch das Lesen von Nachrichten erfordert ihn. Schreibe den Key niemals fest in den Code; lade ihn aus einer Umgebungsvariable. Rate-Limits gelten pro Key und sind großzügig genug für normale Test- und CI-Nutzung; wenn du umfangreiche Lasttests fährst, füge ein kleines Backoff zwischen den Aufrufen ein (die Abruf-Schleife wartet bereits 3s zwischen den Versuchen).
Q5Wie lange lebt das Postfach?+
Die Lebensdauer des Postfachs wird durch den ttlMinutes-Wert bestimmt, den du beim Erstellen übergibst — zum Beispiel 30 Minuten. Sobald die TTL abläuft, werden das Postfach und seine Nachrichten gelöscht und der Session-Token liefert keine Mail mehr zurück. Erstelle daher für jeden Lauf ein frisches Postfach, statt einen alten Token wiederzuverwenden.
Temp Mail in anderen Sprachen
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.