API Documentazione

API di rilevamento email usa e getta semplice, veloce e gratuita. Nessuna autenticazione richiesta, controlla semplicemente il codice di stato HTTP per risultati istantanei.

Avvio Rapido

Inizia in pochi secondi con la nostra semplice API REST. Nessuna chiave API, nessuna registrazione, nessuna configurazione complessa - invia semplicemente una richiesta GET e controlla il codice di stato HTTP per il risultato.

RICHIESTA GET
https://disposableemailchecker.com/api/check?email=test@10minutemail.com
USA E GETTA (Stato: 403)
Questo sembra essere un indirizzo email usa e getta
LEGITTIMA (Stato: 200)
Questa email sembra legittima

Come Funziona

La nostra API utilizza i codici di stato HTTP per indicare il risultato, rendendo l'integrazione estremamente semplice. Il corpo della risposta contiene un messaggio leggibile dall'uomo per contesto aggiuntivo.

Logica dei Codici di Stato

200
L'email è legittima - Consenti registrazione
403
L'email è usa e getta - Blocca registrazione
4xx/5xx
Si è verificato un errore - Controlla il corpo della risposta per i dettagli

Endpoint API

1. Endpoint di Controllo Email

Controlla se un indirizzo email completo è usa e getta. Questo è il caso d'uso più comune per la validazione di registrazione utente.

Metodo:GET
Risposta:text/plain
URL:/api/check?email={email}

2. Endpoint di Controllo Dominio (Rispettoso della Privacy)

Per una migliore privacy, puoi controllare solo la parte del dominio invece dell'indirizzo email completo. Questo impedisce che qualsiasi informazione personale venga trasmessa o registrata.

Suggerimento Privacy

Utilizzare il controllo solo del dominio significa che nessun indirizzo email personale viene trasmesso ai nostri server, fornendo la massima privacy pur ottenendo un rilevamento accurato delle email usa e getta.

Metodo:GET
Risposta:text/plain
URL:/api/check?domain={domain}

Esempi di Codice

Ecco esempi pratici nei linguaggi di programmazione più popolari. Concentrati sul codice di stato HTTP per il risultato, e opzionalmente leggi il corpo della risposta per messaggi leggibili dall'uomo.

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

Riga di 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

Migliori Pratiche

Usa il Controllo Dominio per la Privacy

Quando possibile, estrai il dominio dagli indirizzi email lato client e invia solo il dominio alla nostra API. Questo impedisce che qualsiasi indirizzo email personale venga trasmesso o registrato, fornendo la massima protezione della privacy.

Concentrati sui Codici di Stato

Il codice di stato HTTP ti dice tutto quello che devi sapere. 200 = consenti, 403 = blocca. Puoi opzionalmente leggere il corpo della risposta per messaggi leggibili dall'uomo, ma il codice di stato è sufficiente per la maggior parte dei casi d'uso.

Gestisci gli Errori con Eleganza

Implementa sempre una logica di fallback quando l'API non è disponibile. In caso di errori (codici di stato 4xx/5xx), considera di permettere alla registrazione di procedere piuttosto che bloccare utenti legittimi. Imposta timeout ragionevoli (3-5 secondi).

Implementa la Cache

Memorizza in cache i risultati per domini comuni per ridurre le chiamate API e migliorare le prestazioni. La maggior parte dei domini email usa e getta non cambia stato frequentemente, quindi la cache per 24-48 ore è generalmente sicura e riduce il carico del server.

Blocco Intelligente in Produzione

Negli ambienti di produzione, non bloccare immediatamente gli utenti quando viene rilevata un'email usa e getta. Invece, combina il risultato dell'API con altri fattori: controlla se più di 5 utenti usano già questo dominio, o se più di 3 registrazioni da questo dominio sono avvenute nelle ultime 24 ore. Solo allora chiedi agli utenti di usare un'email diversa. Questo approccio migliora l'esperienza utente e riduce l'impatto dei falsi positivi.

Limiti di Velocità e Uso Equo

La nostra API è gratuita e non impone limiti di velocità rigorosi, ma ti chiediamo di usarla responsabilmente per garantire buone prestazioni per tutti.

Linee Guida per l'Uso Equo

  • Volumi di richieste ragionevoli per l'uso normale dell'applicazione
  • Implementa la cache per evitare richieste ripetute per gli stessi domini
  • Non usare l'API per scansioni massive di domini o scopi di ricerca
  • Contattaci se hai bisogno di limiti più alti per casi d'uso legittimi

Supporto e Feedback

Hai bisogno di aiuto per integrare la nostra API o hai trovato un dominio classificato erroneamente? Siamo qui per aiutare e cerchiamo sempre di migliorare la nostra accuratezza di rilevamento.

Supporto Tecnico

Problemi con l'integrazione? Hai bisogno di aiuto per un caso d'uso specifico? Contatta il nostro team tecnico.

Ottieni Aiuto Tecnico

Invia Feedback sui Domini

Hai trovato un falso positivo o negativo? Aiutaci a migliorare inviando feedback sui domini. Esaminiamo tutte le segnalazioni entro 24 ore.

Invia Feedback