API Dokumentation

Einfache, schnelle und kostenlose Wegwerf-E-Mail-Erkennungs-API. Keine Authentifizierung erforderlich, prüfen Sie einfach den HTTP-Statuscode für sofortige Ergebnisse.

Schnellstart

Starten Sie in Sekunden mit unserer einfachen REST-API. Keine API-Schlüssel, keine Registrierung, keine komplexe Einrichtung - senden Sie einfach eine GET-Anfrage und prüfen Sie den HTTP-Statuscode für das Ergebnis.

GET-ANFRAGE
https://disposableemailchecker.com/api/check?email=test@10minutemail.com
WEGWERF (Status: 403)
Dies scheint eine Wegwerf-E-Mail-Adresse zu sein
LEGITIM (Status: 200)
Diese E-Mail sieht legitim aus

Wie Es Funktioniert

Unsere API verwendet HTTP-Statuscodes, um das Ergebnis anzuzeigen, was die Integration extrem einfach macht. Der Antworttext enthält eine menschenlesbare Nachricht für zusätzlichen Kontext.

Statuscode-Logik

200
E-Mail ist legitim - Registrierung erlauben
403
E-Mail ist Wegwerf - Registrierung blockieren
4xx/5xx
Fehler aufgetreten - Prüfen Sie den Antworttext für Details

API-Endpunkte

1. E-Mail-Prüfungs-Endpunkt

Prüfen Sie, ob eine vollständige E-Mail-Adresse Wegwerf ist. Dies ist der häufigste Anwendungsfall für die Benutzerregistrierungsvalidierung.

Methode:GET
Antwort:text/plain
URL:/api/check?email={email}

2. Domain-Prüfungs-Endpunkt (Datenschutzfreundlich)

Für besseren Datenschutz können Sie nur den Domain-Teil anstatt der vollständigen E-Mail-Adresse prüfen. Dies verhindert, dass persönliche Informationen übertragen oder protokolliert werden.

Datenschutz-Tipp

Die Verwendung der reinen Domain-Prüfung bedeutet, dass keine persönlichen E-Mail-Adressen an unsere Server übertragen werden, was maximalen Datenschutz bei gleichzeitig genauer Wegwerf-E-Mail-Erkennung bietet.

Methode:GET
Antwort:text/plain
URL:/api/check?domain={domain}

Code-Beispiele

Hier sind praktische Beispiele in beliebten Programmiersprachen. Konzentrieren Sie sich auf den HTTP-Statuscode für das Ergebnis und lesen Sie optional den Antworttext für menschenlesbare Nachrichten.

JavaScript / Node.js

JAVASCRIPT
async function checkEmail(email) {
  try {
    const response = await fetch(
      `https://disposableemailchecker.com/api/check?email=${encodeURIComponent(email)}`
    );
    
    if (response.status === 200) {
      const message = await response.text();
      console.log('✅ Valid email:', message);
      return true; // Allow registration
    } else if (response.status === 403) {
      const message = await response.text();
      console.log('❌ Disposable email:', message);
      return false; // Block registration
    } else {
      const error = await response.text();
      console.log(`⚠️ Check failed (${response.status}):`, error);
      return null; // Handle error
    }
  } catch (error) {
    console.error('❌ Request failed:', error);
    return null;
  }
}

// Domain check (privacy-friendly)
async function checkDomain(domain) {
  try {
    const response = await fetch(
      `https://disposableemailchecker.com/api/check?domain=${encodeURIComponent(domain)}`
    );
    
    return response.status === 200; // true = legitimate, false = disposable
  } catch (error) {
    console.error('❌ Request failed:', error);
    return null;
  }
}

// Usage examples
checkEmail('user@gmail.com');
checkEmail('test@10minutemail.com');
checkDomain('gmail.com');

Python

PYTHON
import requests
from urllib.parse import quote

def check_email(email):
    """Check if email is disposable"""
    url = f"https://disposableemailchecker.com/api/check?email={quote(email)}"
    
    try:
        response = requests.get(url, timeout=5)
        
        if response.status_code == 200:
            print(f"✅ Valid email: {response.text}")
            return True  # Allow registration
        elif response.status_code == 403:
            print(f"❌ Disposable email: {response.text}")
            return False  # Block registration
        else:
            print(f"⚠️ Check failed ({response.status_code}): {response.text}")
            return None  # Handle error
            
    except requests.RequestException as e:
        print(f"❌ Request failed: {e}")
        return None

def check_domain(domain):
    """Check domain only (privacy-friendly)"""
    url = f"https://disposableemailchecker.com/api/check?domain={quote(domain)}"
    
    try:
        response = requests.get(url, timeout=5)
        return response.status_code == 200  # True = legitimate, False = disposable
    except requests.RequestException as e:
        print(f"❌ Request failed: {e}")
        return None

# Usage examples
check_email('user@gmail.com')
check_email('test@10minutemail.com')
check_domain('gmail.com')

PHP

PHP
<?php
function checkEmail($email) {
    $url = 'https://disposableemailchecker.com/api/check?email=' . urlencode($email);
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 5);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        echo "✅ Valid email: " . $response . "\n";
        return true; // Allow registration
    } elseif ($httpCode === 403) {
        echo "❌ Disposable email: " . $response . "\n";
        return false; // Block registration
    } else {
        echo "⚠️ Check failed ({$httpCode}): " . $response . "\n";
        return null; // Handle error
    }
}

function checkDomain($domain) {
    $url = 'https://disposableemailchecker.com/api/check?domain=' . urlencode($domain);
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 5);
    curl_setopt($ch, CURLOPT_NOBODY, true); // HEAD request for status only
    
    curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    return $httpCode === 200; // true = legitimate, false = disposable
}

// Usage examples
checkEmail('user@gmail.com');
checkEmail('test@10minutemail.com');
var_dump(checkDomain('gmail.com'));
?>

cURL Kommandozeile

CURL
# Check email with status code and response
curl -w "HTTP Status: %{http_code}\n" \
  "https://disposableemailchecker.com/api/check?email=test@10minutemail.com"

# Check domain only (privacy-friendly)
curl -w "HTTP Status: %{http_code}\n" \
  "https://disposableemailchecker.com/api/check?domain=10minutemail.com"

# Get only status code (for scripts)
curl -s -o /dev/null -w "%{http_code}" \
  "https://disposableemailchecker.com/api/check?email=user@gmail.com"

# Batch check multiple emails
for email in "user@gmail.com" "test@tempmail.org" "admin@yahoo.com"; do
  echo "Checking $email:"
  curl -w "Status: %{http_code}\n" \
    "https://disposableemailchecker.com/api/check?email=$email"
  echo "---"
done

Best Practices

Verwenden Sie Domain-Prüfung für Datenschutz

Wenn möglich, extrahieren Sie die Domain aus E-Mail-Adressen clientseitig und senden Sie nur die Domain an unsere API. Dies verhindert, dass persönliche E-Mail-Adressen übertragen oder protokolliert werden und bietet maximalen Datenschutz.

Konzentrieren Sie sich auf Statuscodes

Der HTTP-Statuscode sagt Ihnen alles, was Sie wissen müssen. 200 = erlauben, 403 = blockieren. Sie können optional den Antworttext für menschenlesbare Nachrichten lesen, aber der Statuscode ist für die meisten Anwendungsfälle ausreichend.

Behandeln Sie Fehler Elegant

Implementieren Sie immer Fallback-Logik für den Fall, dass die API nicht verfügbar ist. Bei Fehlern (4xx/5xx-Statuscodes) erwägen Sie, die Registrierung fortzusetzen, anstatt legitime Benutzer zu blockieren. Setzen Sie angemessene Timeouts (3-5 Sekunden).

Implementieren Sie Caching

Cachen Sie Ergebnisse für häufige Domains, um API-Aufrufe zu reduzieren und die Leistung zu verbessern. Die meisten Wegwerf-E-Mail-Domains ändern ihren Status nicht häufig, daher ist Caching für 24-48 Stunden normalerweise sicher und reduziert die Serverlast.

Intelligentes Blockieren in der Produktion

In Produktionsumgebungen blockieren Sie Benutzer nicht sofort, wenn eine Wegwerf-E-Mail erkannt wird. Kombinieren Sie stattdessen das API-Ergebnis mit anderen Faktoren: Prüfen Sie, ob bereits mehr als 5 Benutzer diese Domain verwenden oder ob mehr als 3 Registrierungen von dieser Domain in den letzten 24 Stunden aufgetreten sind. Erst dann fordern Sie Benutzer auf, eine andere E-Mail zu verwenden. Dieser Ansatz verbessert die Benutzererfahrung und reduziert die Auswirkungen von Falsch-Positiven.

Ratenlimits & Faire Nutzung

Unsere API ist kostenlos und erzwingt keine strengen Ratenlimits, aber wir bitten Sie, sie verantwortungsvoll zu nutzen, um gute Leistung für alle zu gewährleisten.

Faire Nutzungsrichtlinien

  • Angemessene Anfragevolumen für normale Anwendungsnutzung
  • Implementieren Sie Caching, um wiederholte Anfragen für dieselben Domains zu vermeiden
  • Verwenden Sie die API nicht für Massen-Domain-Scanning oder Forschungszwecke
  • Kontaktieren Sie uns, wenn Sie höhere Limits für legitime Anwendungsfälle benötigen

Support & Feedback

Benötigen Sie Hilfe bei der Integration unserer API oder haben Sie eine falsch klassifizierte Domain gefunden? Wir sind hier, um zu helfen und suchen immer nach Möglichkeiten, unsere Erkennungsgenauigkeit zu verbessern.

Technischer Support

Probleme mit der Integration? Benötigen Sie Hilfe bei einem spezifischen Anwendungsfall? Wenden Sie sich an unser technisches Team.

Technische Hilfe Erhalten

Domain-Feedback Einreichen

Einen Falsch-Positiv oder -Negativ gefunden? Helfen Sie uns, uns zu verbessern, indem Sie Domain-Feedback einreichen. Wir überprüfen alle Einreichungen innerhalb von 24 Stunden.

Feedback Einreichen