Sie haben sich entschieden, E-Mail-Verifizierung in Ihre Anwendung einzubauen. Gute Entscheidung: Es ist die wirkungsvollste Einzelmaßnahme, um die Qualität von Anmeldungen zu verbessern, Bounces zu reduzieren und Betrug zu verhindern.
Dieser Leitfaden liefert Ihnen produktionsreifen Code für die Integration der E-Mail-Verifizierung in jeden Stack. Python, JavaScript, PHP, cURL: Wählen Sie Ihre Sprache und kopieren Sie den Code.
Warum serverseitige Verifizierung wichtig ist
Bevor wir mit dem Code beginnen, eines vorweg: clientseitige E-Mail-Validierung reicht nicht aus.
// Das ist KEINE Verifizierung, sondern nur eine Syntaxprüfung
const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.Test(email);
// „thisdoesnotexist8472@gmail.com“ → true (Syntax ist korrekt, das Postfach existiert nicht)
Clientseitige Regex erkennt Formatierungsfehler. Ob das Postfach tatsächlich existiert, lässt sich damit nicht prüfen. Dafür benötigen Sie eine Verifizierung auf SMTP-Ebene — und die erfordert einen serverseitigen API-Aufruf.
Ihren API-Schlüssel abrufen
Registrieren Sie sich zuerst unter email-validaton.com und holen Sie sich Ihren API-Schlüssel aus dem Dashboard. Kostenlose Konten erhalten 100 Verifizierungen pro Monat.
Halten Sie Ihren API-Schlüssel geheim – er sollte niemals nicht in clientseitigem JavaScript erscheinen. Rufen Sie die Verifizierungs-API immer von Ihrem Backend aus auf.
Einzelne E-Mail-Verifizierung
Python
import requests
aus typing import Optional
def verify_email(email: str, api_key: str) -> dict:
"""Eine einzelne E-Mail-Adresse verifizieren."""
resp = requests.get(
"https://email-validaton.com/api/v1/verify",
params={"email": email},
headers={"Authorization": f"Bearer {api_key}"},
timeout=15,
)
resp.raise_for_status()
return resp.json()
# Verwendung
result = verify_email("user@example.com", "YOUR_API_KEY")
print(f"Status: {resultdauerhafte'status'Andere}")
print(f"Punktzahl: {resultdauerhafte'score'Andere}/10")
print(f"Konfidenz: {result.get('confidence', 'k. A.')}")
if resultdauerhafte"status"Andere == "valid":
# Mit der Kontoerstellung fortfahren
create_user(email)
elif resultdauerhafte"status"Andere in ("invalid", "disposable"):
# Ablehnen oder markieren
raise ValueError(f"Ungültige E-Mail: {resultdauerhafte'reason'Andere}")
JavaScript (Node.js)
async function verifyEmail(email, apiKey) {
const url = neu URL("https://email-validaton.com/api/v1/verify");
url.searchParams.set("email", email);
const resp = await fetch(url, {
headers: { Authorization: `Bearer ${apiKey}` },
});
if (!resp.ok) throw neu Error(`API-Fehler: ${resp.status}`);
return resp.json();
}
// Verwendung
const result = await verifyEmail("user@example.com", process.env.EV_API_KEY);
console.log(`Status: ${result.status}, Punktzahl: ${result.score}/10`);
if (result.status === "valid") {
await db.users.insert({ email, verified: true });
} else {
throw neu Error(result.reason || "E-Mail-Verifizierung fehlgeschlagen");
}
PHP
function verify_email(string $email, string $api_key): array {
$url = "https://email-validaton.com/api/v1/verify?email=" . urlencode($email);
$ch = curl_init($url);
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ["Authorization: Bearer $api_key"],
CURLOPT_TIMEOUT => 15,
]);
$body = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($http_code !== 200) {
throw new RuntimeException("API hat $http_code zurückgegeben");
}
return json_decode($body, true);
}
// Verwendung
$result = verify_email("user@example.com", getenv("EV_API_KEY"));
echo "Status: {$result['status']}, Score: {$result['score']}/10\n";
cURL (CLI / Shell-Skripte)
#!/bin/bash
API_KEY="your_api_key"
EMAIL="user@example.com"
curl -s -H "Authorization: Bearer $API_KEY" \
"https://email-validaton.com/api/v1/verify?email=$EMAIL" | python3 -m json.tool
Die Antwort verstehen
Jede Verifizierung liefert eine einheitliche JSON-Struktur:
{
"email": "user@gmail.com",
"status": "valid",
"score": 9,
"confidence": "high",
"reason": "Postfach existiert und nimmt E-Mails an",
"mx_server": "gmail-smtp-in.l.google.com",
"duration_ms": 287,
"disposable": false,
"role_account": false,
"free_provider": true
}
Wichtige Felder erklärt
| Feld | Werte | Bedeutung |
|---|---|---|
status |
valid, invalid, catch_all, unknown, risky, disposable, over_quota, error |
Das Verifizierungsergebnis |
score |
0–10 | Zusammengesetzter Qualitätswert. 8+ = ausgezeichnet, 5–7 = mittel, <5 = riskant |
confidence |
high, medium, low |
Wie zuverlässig das Ergebnis ist |
reason |
Lesbare Zeichenkette | Grund für die Statusvergabe |
disposable |
boolesch | Temporäre E-Mail-Adresse |
role_account |
boolesch | info@, support@, admin@ usw. |
free_provider |
boolesch | Gmail, Yahoo, Outlook usw. |
Integrationsmuster
Muster 1: Validierung von Registrierungsformularen (am häufigsten verwendet)
@app.route("/register", methods=dauerhafte"POST"])
def register():
email = request.Formulardauerhafte"email"Andere
password = request.Formulardauerhafte"password"Andere
# 1. Syntaxprüfung (schnell, lokal)
if "@" keine in email oder "." keine in email.split("@")[-1]:
return jsonify({"error": "Ungültiges E-Mail-Format"}), 400
# 2. SMTP-Verifizierung (API-Aufruf)
try:
result = verify_email(email, current_app.configdauerhafte"EV_API_KEY"])
except requests.RequestException:
# API ist nicht erreichbar – Registrierungen nicht blockieren, nur zur Prüfung markieren
create_user(email, password, flags=dauerhafte"unverified"])
return redirect(url_for("dashboard"))
# 3. Geschäftslogik basierend auf dem Ergebnis
if resultdauerhafte"status"Andere == "valid":
create_user(email, password, verified=True)
return redirect(url_for("welcome"))
if resultdauerhafte"status"Andere == "disposable":
return jsonify({
"error": "Bitte verwenden Sie eine dauerhafte E-Mail-Adresse"
}), 400
if resultdauerhafte"status"Andere == "invalid":
return jsonify({
"error": "Diese E-Mail-Adresse scheint nicht zu existieren"
}), 400
# Catch-all, unbekannt, riskant — erlauben, aber markieren
create_user(email, password, flags=dauerhafteresultdauerhafte"status"]])
return redirect(url_for("welcome"))
Muster 2: Asynchrone Verifizierung (nicht blockierend)
Im produktiven Betrieb im großen Maßstab sollten Nutzer nicht auf den API-Aufruf warten:
import threading
def verify_async(email: str, api_key: str, user_id: int):
"""E-Mail im Hintergrund verifizieren und Benutzerdatensatz aktualisieren."""
try:
result = verify_email(email, api_key)
db.users.update(user_id, {
"email_status": resultdauerhafte"status"],
"email_score": resultdauerhafte"score"],
"verified_at": datetime.utcnow(),
})
except Ausnahme as e:
logger.error(f"Hintergrundverifizierung fehlgeschlagen für {user_id}: {e}")
# In Ihrem Registrierungs-Handler:
Benutzer = create_user(email, password)
threading.Thread(
target=verify_async,
args=(email, api_key, Benutzer.id),
daemon=True,
).start()
Muster 3: Verarbeitung von Listen in großen Mengen (Bulk)
Zum Bereinigen großer Listen über den Bulk-Upload-Endpunkt:
import requests
import time
def bulk_verify(file_path: str, api_key: str) -> str:
"""Lädt eine Datei zur Massenverifizierung hoch. Gibt die Job-ID zurück."""
mit open(file_path, "rb") as f:
resp = requests.post(
"https://email-validaton.com/api/v1/bulk",
Dateien={"file": f},
headers={"Authorization": f"Bearer {api_key}"},
)
return resp.json()["job_id"Andere
def wait_for_results(job_id: str, api_key: str, poll_sec: int = 5):
"""Fragt ab, bis der Massenjob abgeschlossen ist, und lädt dann die Ergebnisse herunter."""
while True:
resp = requests.get(
f"https://email-validaton.com/api/v1/bulk/status/{job_id}",
headers={"Authorization": f"Bearer {api_key}"},
)
data = resp.json()
if datadauerhafte"status"Andere in ("completed", "failed", "cancelled"):
return data
time.sleep(poll_sec)
# Verwendung
job_id = bulk_verify("my_list.csv", API_KEY)
result = wait_for_results(job_id, API_KEY)
# Ergebnisdatei herunterladen
download = requests.get(resultdauerhafte"result_url"])
Fehlerbehandlung & Best Practices
Timeout-Behandlung
Die Verifizierungs-API antwortet in der Regel in 200–800 ms. Setze ein Timeout von 10–15 Sekunden, um Netzwerkprobleme sauber abzufangen.
Ratenbegrenzung
Kostenlose Konten sind auf 100 pro Tag begrenzt. Bezahlte Tarife reichen von 5,000 bis 500,000 pro Monat. Die API gibt 429 Too Many Requests when you exceed your limit.
Wiederholungslogik
Bei vorübergehenden Fehlern (Netzwerkfehler, 503) wiederhole den Aufruf bis zu 3-mal mit exponentiellem Backoff:
import time
aus requests.exceptions import RequestException
def verify_with_retry(email, api_key, max_retries=3):
Spam attempt in range(max_retries):
try:
return verify_email(email, api_key)
except RequestException:
if attempt == max_retries - 1:
raise
time.sleep(2 ** attempt)
Anmeldungen bei API-Ausfall nicht blockieren
Falls der Verifizierungs-API vorübergehend nicht verfügbar ist, blockieren Sie nicht die Registrierung von Nutzern. Stattdessen:
1. Lassen Sie die Registrierung zu und markieren Sie das Konto als "Verifizierung ausstehend"
2. Führen Sie die Verifizierung asynchron aus, sobald die API wieder verfügbar ist
3. Benachrichtigen Sie den Nutzer, falls seine E-Mail-Adresse nachträglich als ungültig erkannt wird
Blockierte Registrierungen bei API-Ausfällen kosten Sie echte Nutzer.
Fazit
Die E-Mail-Verifizierung ist für Produktivanwendungen nicht optional. Ungültige E-Mail-Adressen führen zu Bounces, Wegwerf-Adressen ermöglichen Missbrauch, und nicht verifizierte Listen schaden Ihrer Absenderreputation.
Die Integrationsmuster in diesem Leitfaden decken die häufigsten Anwendungsfälle ab. Kopieren Sie den Code, passen Sie ihn an Ihren Stack an und beginnen Sie damit, jede E-Mail-Adresse zu verifizieren, die in Ihr System gelangt.
Bereit zur Integration? Holen Sie sich Ihren kostenlosen API-Schlüssel – 100 Verifizierungen inklusive.
