API Documentação

API de detecção de email descartável simples, rápida e gratuita. Nenhuma autenticação necessária, apenas verifique o código de status HTTP para resultados instantâneos.

Início Rápido

Comece em segundos com nossa API REST simples. Sem chaves API, sem registro, sem configuração complexa - apenas envie uma requisição GET e verifique o código de status HTTP para o resultado.

REQUISIÇÃO GET

https://disposableemailchecker.com/api/check?email=test@10minutemail.com

DESCARTÁVEL (Status: 403)

Este parece ser um endereço de email descartável

LEGÍTIMO (Status: 200)

Este email parece legítimo

Como Funciona

Nossa API usa códigos de status HTTP para indicar o resultado, tornando a integração extremamente simples. O corpo da resposta contém uma mensagem legível para contexto adicional.

Lógica dos Códigos de Status

200

Email é legítimo - Permitir registro

403

Email é descartável - Bloquear registro

4xx/5xx

Erro ocorreu - Verifique o corpo da resposta para detalhes

Endpoints da API

1. Endpoint de Verificação de Email

Verifique se um endereço de email completo é descartável. Este é o caso de uso mais comum para validação de registro de usuário.

Método:GET

Resposta:text/plain

URL:/api/check?email={email}

2. Endpoint de Verificação de Domínio (Amigável à Privacidade)

Para melhor privacidade, você pode verificar apenas a parte do domínio em vez do endereço de email completo. Isso impede que qualquer informação pessoal seja transmitida ou registrada.

Dica de Privacidade

Usar verificação apenas de domínio significa que nenhum endereço de email pessoal é transmitido para nossos servidores, fornecendo máxima privacidade enquanto ainda obtém detecção precisa de email descartável.

Método:GET

Resposta:text/plain

URL:/api/check?domain={domain}

Exemplos de Código

Aqui estão exemplos práticos em linguagens de programação populares. Foque no código de status HTTP para o resultado, e opcionalmente leia o corpo da resposta para mensagens legíveis.

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

Linha de Comando 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

Melhores Práticas

Use Verificação de Domínio para Privacidade

Quando possível, extraia o domínio dos endereços de email no lado do cliente e envie apenas o domínio para nossa API. Isso impede que qualquer endereço de email pessoal seja transmitido ou registrado, fornecendo máxima proteção de privacidade.

Foque nos Códigos de Status

O código de status HTTP te diz tudo que você precisa saber. 200 = permitir, 403 = bloquear. Você pode opcionalmente ler o corpo da resposta para mensagens legíveis, mas o código de status é suficiente para a maioria dos casos de uso.

Trate Erros com Elegância

Sempre implemente lógica de fallback quando a API não estiver disponível. Em caso de erros (códigos de status 4xx/5xx), considere permitir que o registro prossiga em vez de bloquear usuários legítimos. Defina timeouts razoáveis (3-5 segundos).

Implemente Cache

Faça cache dos resultados para domínios comuns para reduzir chamadas de API e melhorar performance. A maioria dos domínios de email descartável não muda de status frequentemente, então fazer cache por 24-48 horas é geralmente seguro e reduz a carga do servidor.

Bloqueio Inteligente em Produção

Em ambientes de produção, não bloqueie usuários imediatamente quando um email descartável for detectado. Em vez disso, combine o resultado da API com outros fatores: verifique se mais de 5 usuários já usam este domínio, ou se mais de 3 registros deste domínio ocorreram nas últimas 24 horas. Só então peça aos usuários para usar um email diferente. Esta abordagem melhora a experiência do usuário e reduz o impacto de falsos positivos.

Limites de Taxa e Uso Justo

Nossa API é gratuita e não impõe limites de taxa rigorosos, mas pedimos que você a use responsavelmente para garantir boa performance para todos.

Diretrizes de Uso Justo

Volumes de requisição razoáveis para uso normal de aplicação
Implemente cache para evitar requisições repetidas para os mesmos domínios
Não use a API para varredura em massa de domínios ou propósitos de pesquisa
Entre em contato conosco se precisar de limites mais altos para casos de uso legítimos

Suporte e Feedback

Precisa de ajuda integrando nossa API ou encontrou um domínio classificado incorretamente? Estamos aqui para ajudar e sempre buscamos melhorar nossa precisão de detecção.

Suporte Técnico

Tendo problemas com integração? Precisa de ajuda com um caso de uso específico? Entre em contato com nossa equipe técnica.

Obter Ajuda Técnica

Enviar Feedback de Domínio

Encontrou um falso positivo ou negativo? Nos ajude a melhorar enviando feedback de domínio. Revisamos todas as submissões dentro de 24 horas.

Enviar Feedback