API Documentation

API de détection d'emails jetables simple, rapide et gratuite. Aucune authentification requise, vérifiez simplement le code de statut HTTP pour des résultats instantanés.

Démarrage Rapide

Commencez en quelques secondes avec notre API REST simple. Pas de clés API, pas d'inscription, pas de configuration complexe - envoyez simplement une requête GET et vérifiez le code de statut HTTP pour le résultat.

REQUÊTE GET
https://disposableemailchecker.com/api/check?email=test@10minutemail.com
JETABLE (Statut: 403)
Ceci semble être une adresse email jetable
LÉGITIME (Statut: 200)
Cet email semble légitime

Comment Ça Marche

Notre API utilise les codes de statut HTTP pour indiquer le résultat, rendant l'intégration extrêmement simple. Le corps de la réponse contient un message lisible par l'homme pour un contexte supplémentaire.

Logique des Codes de Statut

200
L'email est légitime - Autoriser l'inscription
403
L'email est jetable - Bloquer l'inscription
4xx/5xx
Une erreur s'est produite - Vérifiez le corps de la réponse pour les détails

Points de Terminaison API

1. Point de Terminaison de Vérification d'Email

Vérifiez si une adresse email complète est jetable. C'est le cas d'usage le plus courant pour la validation d'inscription d'utilisateur.

Méthode :GET
Réponse :text/plain
URL :/api/check?email={email}

2. Point de Terminaison de Vérification de Domaine (Respectueux de la Vie Privée)

Pour une meilleure confidentialité, vous pouvez vérifier seulement la partie domaine au lieu de l'adresse email complète. Cela empêche toute information personnelle d'être transmise ou enregistrée.

Conseil de Confidentialité

Utiliser la vérification de domaine uniquement signifie qu'aucune adresse email personnelle n'est transmise à nos serveurs, offrant une confidentialité maximale tout en obtenant une détection précise des emails jetables.

Méthode :GET
Réponse :text/plain
URL :/api/check?domain={domain}

Exemples de Code

Voici des exemples pratiques dans les langages de programmation populaires. Concentrez-vous sur le code de statut HTTP pour le résultat, et lisez optionnellement le corps de la réponse pour des messages lisibles par l'homme.

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'));
?>

Ligne de Commande cURL

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

Meilleures Pratiques

Utilisez la Vérification de Domaine pour la Confidentialité

Quand c'est possible, extrayez le domaine des adresses email côté client et envoyez seulement le domaine à notre API. Cela empêche toute adresse email personnelle d'être transmise ou enregistrée, offrant une protection maximale de la confidentialité.

Concentrez-vous sur les Codes de Statut

Le code de statut HTTP vous dit tout ce que vous devez savoir. 200 = autoriser, 403 = bloquer. Vous pouvez optionnellement lire le corps de la réponse pour des messages lisibles par l'homme, mais le code de statut est suffisant pour la plupart des cas d'usage.

Gérez les Erreurs avec Élégance

Implémentez toujours une logique de repli quand l'API n'est pas disponible. En cas d'erreurs (codes de statut 4xx/5xx), considérez permettre à l'inscription de continuer plutôt que de bloquer les utilisateurs légitimes. Définissez des délais d'attente raisonnables (3-5 secondes).

Implémentez la Mise en Cache

Mettez en cache les résultats pour les domaines courants pour réduire les appels API et améliorer les performances. La plupart des domaines d'emails jetables ne changent pas de statut fréquemment, donc la mise en cache pendant 24-48 heures est généralement sûre et réduit la charge du serveur.

Blocage Intelligent en Production

Dans les environnements de production, ne bloquez pas immédiatement les utilisateurs quand un email jetable est détecté. Au lieu de cela, combinez le résultat de l'API avec d'autres facteurs : vérifiez si plus de 5 utilisateurs utilisent déjà ce domaine, ou si plus de 3 inscriptions de ce domaine ont eu lieu dans les dernières 24 heures. Seulement alors demandez aux utilisateurs d'utiliser un email différent. Cette approche améliore l'expérience utilisateur et réduit l'impact des faux positifs.

Limites de Taux et Usage Équitable

Notre API est gratuite et n'applique pas de limites de taux strictes, mais nous vous demandons de l'utiliser de manière responsable pour assurer de bonnes performances pour tout le monde.

Directives d'Usage Équitable

  • Volumes de requêtes raisonnables pour l'usage normal d'application
  • Implémentez la mise en cache pour éviter les requêtes répétées pour les mêmes domaines
  • N'utilisez pas l'API pour le scan en masse de domaines ou à des fins de recherche
  • Contactez-nous si vous avez besoin de limites plus élevées pour des cas d'usage légitimes

Support et Commentaires

Besoin d'aide pour intégrer notre API ou trouvé un domaine mal classifié ? Nous sommes là pour aider et cherchons toujours à améliorer notre précision de détection.

Support Technique

Des problèmes avec l'intégration ? Besoin d'aide pour un cas d'usage spécifique ? Contactez notre équipe technique.

Obtenir de l'Aide Technique

Soumettre des Commentaires sur les Domaines

Trouvé un faux positif ou négatif ? Aidez-nous à nous améliorer en soumettant des commentaires sur les domaines. Nous examinons toutes les soumissions dans les 24 heures.

Soumettre des Commentaires