API Documentación

API de detección de correos desechables simple, rápida y gratuita. No requiere autenticación, solo verifica el código de estado HTTP para obtener resultados instantáneos.

Inicio Rápido

Comienza en segundos con nuestra API REST simple. Sin claves API, sin registro, sin configuración compleja - solo envía una petición GET y verifica el código de estado HTTP para el resultado.

PETICIÓN GET
https://disposableemailchecker.com/api/check?email=test@10minutemail.com
DESECHABLE (Estado: 403)
Este parece ser un correo electrónico desechable
LEGÍTIMO (Estado: 200)
Este correo electrónico parece legítimo

Cómo Funciona

Nuestra API usa códigos de estado HTTP para indicar el resultado, haciendo la integración extremadamente simple. El cuerpo de la respuesta contiene un mensaje legible para contexto adicional.

Lógica de Códigos de Estado

200
El correo es legítimo - Permitir registro
403
El correo es desechable - Bloquear registro
4xx/5xx
Ocurrió un error - Verifica el cuerpo de la respuesta para detalles

Endpoints de API

1. Endpoint de Verificación de Correo

Verifica si una dirección de correo completa es desechable. Este es el caso de uso más común para validación de registro de usuarios.

Método:GET
Respuesta:text/plain
URL:/api/check?email={email}

2. Endpoint de Verificación de Dominio (Amigable con la Privacidad)

Para mejor privacidad, puedes verificar solo la parte del dominio en lugar de la dirección de correo completa. Esto previene que cualquier información personal sea transmitida o registrada.

Consejo de Privacidad

Usar verificación solo de dominio significa que ninguna dirección de correo personal se transmite a nuestros servidores, proporcionando máxima privacidad mientras obtienes detección precisa de correos desechables.

Método:GET
Respuesta:text/plain
URL:/api/check?domain={domain}

Ejemplos de Código

Aquí tienes ejemplos prácticos en lenguajes de programación populares. Enfócate en el código de estado HTTP para el resultado, y opcionalmente lee el cuerpo de la respuesta para mensajes legibles.

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

Línea de Comandos 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

Mejores Prácticas

Usa Verificación de Dominio para Privacidad

Cuando sea posible, extrae el dominio de las direcciones de correo del lado del cliente y solo envía el dominio a nuestra API. Esto previene que cualquier dirección de correo personal sea transmitida o registrada, proporcionando máxima protección de privacidad.

Enfócate en los Códigos de Estado

El código de estado HTTP te dice todo lo que necesitas saber. 200 = permitir, 403 = bloquear. Puedes opcionalmente leer el cuerpo de la respuesta para mensajes legibles, pero el código de estado es suficiente para la mayoría de casos de uso.

Maneja Errores con Elegancia

Siempre implementa lógica de respaldo cuando la API no esté disponible. En caso de errores (códigos de estado 4xx/5xx), considera permitir que el registro continúe en lugar de bloquear usuarios legítimos. Establece timeouts razonables (3-5 segundos).

Implementa Caché

Almacena en caché los resultados para dominios comunes para reducir llamadas a la API y mejorar el rendimiento. La mayoría de dominios de correo desechable no cambian de estado frecuentemente, así que el caché por 24-48 horas es generalmente seguro y reduce la carga del servidor.

Bloqueo Inteligente en Producción

En entornos de producción, no bloquees inmediatamente a los usuarios cuando se detecte un correo desechable. En su lugar, combina el resultado de la API con otros factores: verifica si más de 5 usuarios ya usan este dominio, o si más de 3 registros de este dominio ocurrieron en las últimas 24 horas. Solo entonces solicita a los usuarios usar un correo diferente. Este enfoque mejora la experiencia del usuario y reduce el impacto de falsos positivos.

Límites de Velocidad y Uso Justo

Nuestra API es gratuita y no impone límites de velocidad estrictos, pero te pedimos que la uses responsablemente para asegurar buen rendimiento para todos.

Pautas de Uso Justo

  • Volúmenes de peticiones razonables para uso normal de aplicación
  • Implementa caché para evitar peticiones repetidas para los mismos dominios
  • No uses la API para escaneo masivo de dominios o propósitos de investigación
  • Contáctanos si necesitas límites más altos para casos de uso legítimos

Soporte y Comentarios

¿Necesitas ayuda integrando nuestra API o encontraste un dominio mal clasificado? Estamos aquí para ayudar y siempre buscamos mejorar nuestra precisión de detección.

Soporte Técnico

¿Problemas con la integración? ¿Necesitas ayuda con un caso de uso específico? Contacta a nuestro equipo técnico.

Obtener Ayuda Técnica

Enviar Comentarios de Dominio

¿Encontraste un falso positivo o negativo? Ayúdanos a mejorar enviando comentarios de dominio. Revisamos todas las submisiones dentro de 24 horas.

Enviar Comentarios