E-Mail-Validierungs-API in Echtzeit für Anmeldeformulare

Prüfen Sie Adressen in dem Moment, in dem Nutzer sie absenden: Mailserver und Existenz des Postfachs in einem Aufruf, dazu Kennzeichnungen für Wegwerf- und Rollen-Adressen. So entscheiden Sie selbst, was Sie annehmen. Unsere E-Mail-Validierungs-API blockiert fehlerhafte Daten, bevor sie in Ihre Datenbank gelangen. So bleiben gefälschte Konten draußen.

Backend-Handler für AnmeldungenFormular-Entscheidung
// 1. Receive submitted form data
const { email } = req.body;

// 2. Validate via API
const { data } = await checkEmail(email);

// 3. Make real-time form decision
if (data.status === 'undeliverable') {
  return res.status(400).json({ error: 'Please enter a valid, active email address.' });
}
if (data.details.attributes.disposable) {
  return res.status(400).json({ error: 'Temporary or disposable emails are not allowed.' });
}

// 4. Proceed with account registration
await createUser({ email });

1.000 kostenlose Credits, ohne Karte. Credits verfallen nie.

Warum ein Regex allein keine E-Mail-Validierung ist

Ein regulärer Ausdruck prüft nur die Struktur des Textes: ob ein @-Zeichen vorhanden ist, ob das Domain-Format plausibel aussieht und ob die Zeichen im üblichen ASCII-Bereich liegen. Ein Regex beantwortet nur, ob eine Eingabe wie eine E-Mail-Adresse aussieht. Er sagt nicht, ob dort jemand Nachrichten empfangen kann.

Die Eingabe user@example.com oder asdf12345@gmail.com besteht jeden RFC-konformen Regex. Trotzdem hat die eine Domain vielleicht keine aktiven Mailserver, und das andere Postfach existiert vielleicht nicht.

Unsere E-Mail-Validierungs-API mit JSON-Antwort geht weit über reguläre Ausdrücke hinaus. In einer einzigen Anfrage prüft sie die DNS-Einträge, fragt die MX-Server ab, verbindet sich mit dem Ziel-Mailserver, um zu testen, ob das Postfach antwortet, und gleicht die Domain mit umfangreichen Listen von Wegwerf-Domains ab.

Starre Regex-Muster führen außerdem zu falschen Ablehnungen. Eigene Ausdrücke lehnen oft seltene Top-Level-Domains wie .studio oder .cloud ab, gültige internationale Zeichen oder echte Adressen mit ungewöhnlicher Zeichensetzung. Unsere API beherrscht automatisch die gesamte Syntax nach RFC 5322. Sie müssen keine anfälligen Regex-Bibliotheken in Ihrem Code pflegen.

1

Syntax-Prüfung

Findet einfache Tippfehler, fehlende TLDs, unzulässige Zeichen und Leerzeichen, noch vor jeder externen Netzwerkabfrage.

2

DNS- und MX-Prüfung

Prüft, ob die Domain registriert ist, und findet die eingerichteten Mailserver, die eingehende Nachrichten annehmen können.

3

Postfach-Prüfung

Spricht direkt mit dem entfernten Mailserver und bestätigt, ob genau dieses Postfach existiert und E-Mails empfangen kann.

Was Sie bei der Anmeldung blockieren, markieren oder zulassen

Jedes Unternehmen hat andere Anforderungen an die Anmeldung. Ein B2B-SaaS für Unternehmen verlangt vielleicht Firmenadressen, während eine Social-App für Privatnutzer private Gmail-Adressen gern annimmt. Hier ist die empfohlene Entscheidungstabelle auf Basis echter Attribute der API-Antwort:

API-ErgebnisFeldbedingungWas das Formular tun sollte
Ungültigstatus === "undeliverable"Sofort blockieren. Anzeigen: "Bitte geben Sie eine gültige, aktive E-Mail-Adresse ein."
Wegwerfadressedetails.attributes.disposable === trueBlockieren oder nach einer anderen Adresse fragen. Anzeigen: "Temporäre E-Mail-Adressen sind nicht erlaubt."
Rollen-Adressedetails.attributes.role_account === trueZulassen; in B2B-Formularen markieren. Account Manager benachrichtigen oder in den allgemeinen Lead-Pool leiten.
Freemaildetails.attributes.free_email === trueIn B2C-Apps zulassen; in B2B-Formularen für Demo oder Testzugang eine Firmenadresse verlangen.
Catch-alldetails.attributes.catch_all === truecatch_all_verdict prüfen: bei "valid" zulassen, bei "invalid" blockieren, bei null die Anmeldung zulassen.
Unbekanntstatus === "unknown"Annehmen und später erneut prüfen (wird erstattet). Im Fehlerfall durchlassen (Fail-open), damit echte Nutzer nie blockiert werden.

E-Mail-Validierung in Ihr Anmeldeformular einbauen

Folgen Sie diesen vier Schritten, um die Echtzeit-Validierung sicher einzubinden. Die Anfragen brauchen Ihren privaten API-Key. Führen Sie die Prüfung deshalb auf Ihrem Backend-Server aus.

Warum das Fail-open-Muster wichtig ist: Anmeldeformulare reagieren empfindlich auf Verzögerungen. Wenn ein externer API-Aufruf durch Netzwerklatenz hängt, kann ein blockiertes Formular Sie einen echten Kunden kosten. Mit einem kurzen Timeout und einer Anmeldung, die automatisch weiterläuft, weisen Sie echte Nutzer nicht ab. Ihr Backend stellt die Adresse dann für eine spätere Prüfung im Hintergrund in eine Warteschlange.

1

Formular sendet an Ihr Backend

Wenn ein Besucher seine Anmeldedaten absendet, überträgt der Browser die E-Mail-Adresse an den Endpunkt Ihrer Anwendung.

2

Backend ruft die Validierungs-API auf

Ihr Server sendet eine synchrone POST-Anfrage an Giggal, mit Ihrem privaten Key aus einer Umgebungsvariable.

3

Backend wendet die Entscheidungstabelle an

Werten Sie die JSON-Attribute aus. Ist die E-Mail eine Wegwerfadresse oder unzustellbar, senden Sie eine klare Fehlermeldung an den Browser zurück.

4

Bei Timeouts durchlassen

Wenn die Verbindung zur API in einen Timeout läuft, lassen Sie die Anmeldung zu (Fail-open) und legen einen Hintergrund-Job an, der die Adresse später prüft.

Code-Beispiele für die Einbindung

Backend: Node.js (Express-Route)nur serverseitig
// server.js (Express Route)
const timeoutMs = 5000; // adjust to what your form can tolerate

app.post('/api/signup', async (req, res) => {
  const { email, password } = req.body;

  try {
    const apiRes = await fetch('https://api.giggal.ai/v1/verify', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.GIGGAL_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
      signal: AbortSignal.timeout(timeoutMs), // fail-open timeout
    });

    const result = await apiRes.json();
    if (result.success) {
      const { status, details } = result.data;

      // Decision checks
      if (status === 'undeliverable') {
        return res.status(400).json({ error: 'This email address does not exist.' });
      }
      if (details.attributes.disposable) {
        return res.status(400).json({ error: 'Disposable email addresses are not accepted.' });
      }
    }
  } catch (err) {
    // Fail open: log timeout and let user proceed
    console.warn('Email check timed out, failing open:', err.message);
  }

  // Create user in database
  const user = await db.users.create({ email, password });
  return res.json({ success: true, userId: user.id });
});
Backend: Python (Flask-Route)nur serverseitig
# app.py (Flask Route)
import os, requests
from flask import Flask, request, jsonify

app = Flask(__name__)
timeout_seconds = 5  # adjust to what your form can tolerate

@app.route("/api/signup", methods=["POST"])
def signup():
    email = request.json.get("email")

    try:
        resp = requests.post(
            "https://api.giggal.ai/v1/verify",
            headers={"Authorization": f"Bearer {os.environ['GIGGAL_API_KEY']}"},
            json={"email": email},
            timeout=timeout_seconds  # fail open on timeout
        )
        data = resp.json().get("data", {})
        if data.get("status") == "undeliverable":
            return jsonify({"error": "Email address is invalid."}), 400
        if data.get("details", {}).get("attributes", {}).get("disposable"):
            return jsonify({"error": "Disposable emails are prohibited."}), 400
    except requests.exceptions.RequestException:
        # Fail open: proceed with signup on timeout
        pass

    # Complete user registration
    return jsonify({"success": True})
Frontend: Browser-Client (ruft Ihr eigenes Backend auf)clientseitiges Skript
// Frontend form submit handler
const form = document.querySelector('#signup-form');

form.addEventListener('submit', async (e) => {
  e.preventDefault();
  const email = document.querySelector('#email-input').value;

  const res = await fetch('/api/signup', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ email }),
  });

  const payload = await res.json();
  if (!res.ok) {
    showFormError(payload.error); // Show friendly user feedback
  } else {
    redirectToDashboard();
  }
});

Wichtig: Rufen Sie den Giggal-API-Endpunkt nie direkt aus clientseitigen Skripten auf. Halten Sie Ihre Zugangsdaten auf Ihrem Server.

Wegwerf- und Fake-Anmeldungen stoppen

Temporäre Postfächer verfälschen Ihre Produktanalysen, verbrauchen Testkontingente und werden nie zu zahlenden Kunden. Unser Dienst erkennt und markiert riskante Anmeldemuster.

Wegwerf-Postfächer

Abgeglichen mit unserem aktiven Verzeichnis von über 100.000 temporären Domains. Wie wir Wegwerf-Postfächer erkennen, zeigt unsere Prüfung auf Wegwerf-E-Mails.

Erkennung von Plus-Adressen

Kennzeichnet Aliase mit Plus-Zeichen (user+trial@domain.com). So kann eine Person nicht mehrere Testkonten anlegen.

Erkennung von No-Reply-Postfächern

Erkennt automatische Versand-Postfächer, die eingehende Nachrichten verwerfen. So meldet sich niemand mit einer Adresse an, die nicht antwortet.

Tippfehler nicht automatisch korrigieren

Ändern Sie Eingaben nie still im Hintergrund (zum Beispiel gnail.com automatisch zu gmail.com). Besteht eine Adresse die Validierung nicht, zeigen Sie eine klare Meldung, damit der Nutzer seine Eingabe prüft. Wer still umschreibt, riskiert, dass Aktivierungslinks oder Rechnungen an die falsche Person gehen.

Wo Sie E-Mails in Echtzeit validieren sollten

Validieren Sie E-Mail-Adressen überall dort, wo Nutzer in Ihrem Produkt Formulare absenden.

Registrierungsformulare

Verhindern Sie Spam-Registrierungen und sorgen Sie dafür, dass Willkommens-E-Mails und Bestätigungslinks aktive Postfächer erreichen.

Checkout im Onlineshop

Sorgen Sie dafür, dass Versandinfos, Belege und Bestellbestätigungen ohne Zustellfehler bei den Kunden ankommen.

Kontakt- und Demo-Anfragen

Filtern Sie gefälschte Einträge von Wettbewerbern und prüfen Sie Firmendomains, bevor Sie Interessenten an den Vertrieb geben.

Newsletter-Anmeldungen

Schützen Sie die Reputation Ihrer Versanddomain: Weisen Sie fehlerhafte Eingaben und Bot-Anmeldungen schon beim Opt-in ab.

Webhook-Automatisierungen

Starten Sie die Validierung automatisch über Formular-Webhooks, mit unseren fertigen Integrationen für Zapier und n8n.

Änderungen am Benutzerprofil

Prüfen Sie neue E-Mail-Adressen, wenn bestehende Nutzer ihr Profil oder ihren Rechnungskontakt ändern.

Antwortfelder, die Sie bei der Anmeldung nutzen

Eine kurze Übersicht der wichtigsten JSON-Felder für die Validierungslogik im Formular.

JSON-FeldTypNutzung bei der Anmeldung
data.is_validbooleanSchnelle Boolean-Prüfung. Ist true, wenn die Prüfungen von Domain und Postfach bestanden sind.
data.statusstringWichtigster Zustellstatus: "deliverable", "undeliverable", "unknown".
data.deliverability_scorenumber (0-100)Qualitäts-Score auf Basis der Postfach-Antworten, der Stabilität der MX-Server und der Reputationsprüfungen.
data.details.attributes.disposablebooleanIst true, wenn die Domain ein bekannter Dienst für temporäre oder Wegwerf-Postfächer ist.
data.details.attributes.free_emailbooleanIst true bei Anbietern für Privatnutzer (Gmail, Outlook). In B2B-Formularen Firmendomains verlangen.
data.details.attributes.role_accountbooleanIst true bei Adressen einer Organisation wie info@, admin@ oder support@.
data.catch_all_verdict"valid" | "invalid" | nullPrüfung von Catch-all-Domains im selben Aufruf. Gültige Leads behalten, statt sie zu verwerfen.

Alle Endpunkt-Definitionen, Parameter-Schemas und Fehlercodes finden Sie in der vollständigen API-Referenz.

Preise der E-Mail-Validierungs-API

Sie zahlen nur für die Validierungen, die Sie ausführen, ohne monatliche Mindestbeträge und ohne Bindung. Jeder Validierungsaufruf kostet 1 Credit, die Catch-all-Prüfung im selben Aufruf ist enthalten. Unbekannte Ergebnisse werden automatisch erstattet, und Ihre ersten 1.000 Credits sind komplett kostenlos.

Credits
3.000Credits
Preis0,0017 $ / Credit
Ersparnis
-
Gesamt
5,00 $einmalig
Credits
10.000Credits
Preis0,0010 $ / Credit
Ersparnis
41 % gespart
Gesamt
9,90 $einmalig
Credits
30.000Credits
Preis0,0009 $ / Credit
Ersparnis
44 % gespart
Gesamt
28,00 $einmalig
Credits
50.000Credits
Preis0,0008 $ / Credit
Ersparnis
53 % gespart
Gesamt
39,00 $einmalig
Credits
100.000CreditsAm beliebtesten
Preis0,0008 $ / Credit
Ersparnis
54 % gespart
Gesamt
76,00 $einmalig
Credits
300.000Credits
Preis0,0007 $ / Credit
Ersparnis
56 % gespart
Gesamt
222,00 $einmalig
Credits
500.000Credits
Preis0,0007 $ / Credit
Ersparnis
57 % gespart
Gesamt
360,00 $einmalig
Credits
800.000Credits
Preis0,0007 $ / Credit
Ersparnis
58 % gespart
Gesamt
559,00 $einmalig
Credits
1.000.000Credits
Preis0,0007 $ / Credit
Ersparnis
59 % gespart
Gesamt
680,00 $einmalig

Alle Volumenpläne und Rabatte für Monatsabos finden Sie auf unserer Preisseite.

Häufige Fragen zur E-Mail-Validierungs-API

Antworten auf häufige Fragen zur Einbindung in Anmeldeformulare und zur Validierung in Echtzeit.

Ja. Jedes neue Konto erhält bei der Registrierung 1.000 kostenlose Credits, ohne Kreditkarte. Sie können in Ihrem Entwickler-Dashboard einen API-Key erstellen und die Echtzeit-Validierung von Formularen sofort testen. Die kostenlosen Credits verfallen nie und geben vollen Zugriff auf alle Attribute und Prüfungen.

Nein. Ein Aufruf aus clientseitigem JavaScript würde Ihren geheimen API-Key für jeden sichtbar machen, der die Netzwerkanfragen des Browsers ansieht. Senden Sie Formulardaten immer zuerst an Ihren eigenen Backend-Server oder eine Serverless-Funktion, und lassen Sie Ihren Server die Anfrage an https://api.giggal.ai/v1/verify stellen.

Es wird nie eine Nachricht verschickt. Die API prüft, ob das Postfach existiert. Sie beendet die Verbindung, bevor E-Mail-Daten oder Inhalte übertragen werden. Ihre Nutzer erhalten also nichts in ihrem Posteingang.

Ja. Jede Prüfung gleicht die Domain mit unserem Verzeichnis von über 100.000 Wegwerf- und temporären E-Mail-Domains ab. Bei einem Treffer liefert details.attributes.disposable true, und der Status wird auf undeliverable gesetzt. So kann Ihr Backend temporäre Konten blockieren.

Das hängt von Ihrem Geschäftsmodell ab. In Apps für Privatnutzer können Rollen-Adressen wie support@ oder info@ zu echten Organisationen gehören. Bei Self-Service-B2B-SaaS, wo klar sein muss, wer welches Konto nutzt, markieren oder verbieten viele Unternehmen allgemeine Rollen-Adressen, um geteilte Zugangsdaten zu verhindern.

Catch-all-Domains nehmen jede Empfängeradresse ohne Bedingung an. Normale Prüfungen liefern dort kein klares Ergebnis. Unsere API führt im selben Aufruf eine gründliche Catch-all-Prüfung aus, um festzustellen, ob das Postfach existiert. Liefert die Catch-all-Prüfung "valid", können Sie die Anmeldung sicher zulassen. Bei "invalid" wird die Adresse bouncen, und Sie sollten die Anmeldung stoppen.

Wir empfehlen das Fail-open-Muster. Wenn Ihr Backend-Aufruf in einen Netzwerk-Timeout oder einen Verbindungsfehler läuft, lassen Sie die Anmeldung abschließen, statt einen möglichen Kunden zu blockieren. Stellen Sie die ungeprüfte Adresse in die Warteschlange Ihres Hintergrund-Workers und prüfen Sie den Zustellstatus später erneut.

Wählen Sie eine E-Mail-Validierungs-API, wenn Sie Echtzeit-Prüfungen in Web-Anmeldeformularen brauchen, um Tippfehler, Wegwerf-Postfächer und Bots beim Absenden zu stoppen. Wählen Sie eine E-Mail-Verifizierungs-API, wenn Sie bestehende Marketing-Datenbanken prüfen, CRM-Kontakte abgleichen oder große E-Mail-Dateien vor dem Versand von Kampagnen bereinigen.

Schützen Sie Ihre Anmeldeformulare noch heute

1.000 Credits gratis, keine Kreditkarte nötig.

Kostenlos testen Credits verfallen nicht Erstattung für Unbekannt