Hai deciso di aggiungere la verifica email alla tua applicazione. Ottima scelta: è la modifica con il maggiore impatto per migliorare la qualità delle registrazioni, ridurre i rimbalzi e prevenire le frodi.
Questa guida ti offre codice pronto per la produzione da integrare in qualsiasi stack. Python, JavaScript, PHP, cURL: scegli il tuo linguaggio e copia il codice.
Perché la verifica lato server è importante
Prima di scrivere qualsiasi codice, chiariamo un punto: la validazione email lato client non è sufficiente.
// Questa NON è una verifica — è solo un controllo della sintassi
const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
// "thisdoesnotexist8472@gmail.com" → true (la sintassi è corretta, ma la casella non esiste)
La regex lato client individua errori di formato. Non ti dice se la casella di posta esiste davvero. Per questo serve la verifica a livello SMTP — che richiede una chiamata API lato server.
Ottenere la tua chiave API
Per prima cosa, registrati su email-validaton.com e recupera la tua chiave API dalla dashboard. Gli account gratuiti ottengono 100 verifiche al mese.
Mantieni segreta la tua chiave API: non deve mai comparire nel JavaScript lato client. Richiama sempre l'API di verifica dal tuo backend.
Verifica di una singola email
Python
import requests
from typing import Facoltativo
def verify_email(email: str, api_key: str) -> dict:
"""Verifica un singolo indirizzo email."""
resp = requests.get(
"https://email-validaton.com/api/v1/verify",
params={"email": email},
headers={"Authorization": f"Bearer {api_key}"},
timeout=15,
)
resp.raise_for_status()
return resp.json()
# Utilizzo
result = verify_email("user@example.com", "YOUR_API_KEY")
print(f"Stato: {result['status']}")
print(f"Punteggio: {result['score']}/10")
print(f"Confidenza: {result.get('confidence', 'N/A')}")
if result["status"] == "valid":
# Procedi con la creazione dell'account
create_user(email)
elif result["status"] in ("invalid", "usa e getta"):
# Rifiuta o segnala
raise ValueError(f"Email non valida: {result['reason']}")
JavaScript (Node.js)
async function verifyEmail(email, apiKey) {
const url = new URL("https://email-validaton.com/api/v1/verify");
url.searchParams.set("email", email);
const resp = await fetch(url, {
headers: { Authorization: `Bearer ${apiKey}` },
});
if (!resp.ok) throw new Errore(`Errore API: ${resp.status}`);
return resp.json();
}
// Utilizzo
const result = await verifyEmail("user@example.com", process.env.EV_API_KEY);
console.log(`Stato: ${result.status}, Punteggio: ${result.score}/10`);
if (result.status === "valid") {
await db.users.insert({ email, verified: true });
} else {
throw new Errore(result.reason || "Verifica email non riuscita");
}
PHP
function verify_email(string $email, string $api_key): array {
$url = "https://email-validaton.com/api/v1/verify?email=" . urlencode($email);
$ch = curl_init($url);
curl_setopt_array($ch, [
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => ["Authorization: Bearer $api_key"],
CURLOPT_TIMEOUT => 15,
]);
$body = curl_exec($ch);
$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($http_code !== 200) {
throw new RuntimeException("API ha restituito $http_code");
}
return json_decode($body, true);
}
// Utilizzo
$result = verify_email("user@example.com", getenv("EV_API_KEY"));
echo "Stato: {$result['status']}, Punteggio: {$result['score']}/10\n";
cURL (CLI / Script di shell)
#!/bin/bash
API_KEY="your_api_key"
EMAIL="user@example.com"
curl -s -H "Authorization: Bearer $API_KEY" \
"https://email-validaton.com/api/v1/verify?email=$EMAIL" | python3 -m json.tool
Comprendere la risposta
Ogni verifica restituisce una struttura JSON coerente:
{
"email": "user@gmail.com",
"status": "valid",
"score": 9,
"confidence": "high",
"reason": "La casella di posta esiste e accetta email",
"mx_server": "gmail-smtp-in.l.google.com",
"duration_ms": 287,
"usa e getta": false,
"role_account": false,
"free_provider": true
}
Spiegazione dei campi principali
| Campo | Valori | Significato |
|---|---|---|
status |
valid, invalid, catch_all, unknown, risky, disposable, over_quota, error |
Il risultato della verifica |
score |
0–10 | Punteggio di qualità complessivo. 8+ = eccellente, 5-7 = moderato, <5 = rischioso |
confidence |
high, medium, low |
Quanto è affidabile il risultato |
reason |
Stringa leggibile | Motivo per cui è stato assegnato lo stato |
disposable |
booleano | Indirizzo email temporaneo |
role_account |
booleano | info@, support@, admin@, ecc. |
free_provider |
booleano | Gmail, Yahoo, Outlook, ecc. |
Pattern di integrazione
Pattern 1: Validazione del modulo di registrazione (il più comune)
@app.route("/register", methods=["POST"])
def register():
email = request.modulo["email"]
password = request.modulo["password"]
# 1. Controllo della sintassi (veloce, locale)
if "@" non in email o "." non in email.split("@")[-1]:
return jsonify({"error": "Formato email non valido"}), 400
# 2. Verifica SMTP (chiamata API)
try:
result = verify_email(email, current_app.config["EV_API_KEY"])
except requests.RequestException:
# L'API non è disponibile — non bloccare le registrazioni, segnala solo per la revisione
create_user(email, password, flags=["unverified"])
return redirect(url_for("dashboard"))
# 3. Logica di business basata sul risultato
if result["status"] == "valid":
create_user(email, password, verified=True)
return redirect(url_for("welcome"))
if result["status"] == "usa e getta":
return jsonify({
"error": "Utilizza un indirizzo email permanente"
}), 400
if result["status"] == "invalid":
return jsonify({
"error": "Questo indirizzo email sembra non esistere"
}), 400
# Catch-all, sconosciuto, rischioso — consenti ma segnala
create_user(email, password, flags=[result["status"]])
return redirect(url_for("welcome"))
Pattern 2: verifica asincrona (non bloccante)
In produzione su larga scala, non vuoi che gli utenti attendano la chiamata API:
import threading
def verify_async(email: str, api_key: str, user_id: int):
"""Verifica l'email in background e aggiorna il record utente."""
try:
result = verify_email(email, api_key)
db.users.update(user_id, {
"email_status": result["status"],
"email_score": result["score"],
"verified_at": datetime.utcnow(),
})
except Eccezione as e:
logger.error(f"Verifica in background non riuscita per {user_id}: {e}")
# Nel tuo gestore di registrazione:
user = create_user(email, password)
threading.Thread(
target=verify_async,
args=(email, api_key, user.id),
daemon=True,
).start()
Schema 3: elaborazione di liste in blocco
Per pulire grandi liste tramite l'endpoint di caricamento in blocco:
import requests
import time
def bulk_verify(file_path: str, api_key: str) -> str:
"""Carica un file per la verifica in blocco. Restituisce l'ID del job."""
with open(file_path, "rb") as f:
resp = requests.post(
"https://email-validaton.com/api/v1/bulk",
files={"file": f},
headers={"Authorization": f"Bearer {api_key}"},
)
return resp.json()["job_id"]
def wait_for_results(job_id: str, api_key: str, poll_sec: int = 5):
"""Esegue il polling finché il job bulk non viene completato, poi scarica i risultati."""
while True:
resp = requests.get(
f"https://email-validaton.com/api/v1/bulk/status/{job_id}",
headers={"Authorization": f"Bearer {api_key}"},
)
data = resp.json()
if data["status"] in ("completed", "failed", "cancelled"):
return data
time.sleep(poll_sec)
# Utilizzo
job_id = bulk_verify("my_list.csv", API_KEY)
result = wait_for_results(job_id, API_KEY)
# Scarica il file dei risultati
download = requests.get(result["result_url"])
Gestione degli errori e best practice
Gestione dei timeout
L'API di verifica risponde in genere in 200-800 ms. Imposta un timeout di 10-15 secondi per gestire in modo corretto i problemi di rete.
Limitazione della frequenza
Gli account gratuiti sono limitati a 100/giorno. I piani a pagamento vanno da 5,000 a 500,000/mese. L'API restituisce 429 Too Many Requests when you exceed your limit.
Logica dei tentativi
Per i guasti temporanei (errori di rete, 503), riprova fino a 3 volte con backoff esponenziale:
import time
from requests.exceptions import RequestException
def verify_with_retry(email, api_key, max_retries=3):
for tentativo in intervallo(max_retries):
try:
return verify_email(email, api_key)
except RequestException:
if tentativo == max_retries - 1:
raise
time.sleep(2 ** tentativo)
Non bloccare le registrazioni in caso di errore dell'API
Se l'API di verifica è temporaneamente non disponibile, non bloccare la registrazione dell'utente. Invece:
1. Consenti la registrazione e contrassegna l'account come "in attesa di verifica"
2. Esegui la verifica in modo asincrono quando l'API torna disponibile
3. Avvisa l'utente se la sua email risulta non valida in un secondo momento
Bloccare le registrazioni durante i disservizi dell'API fa perdere utenti reali.
Conclusione
La verifica dell'email non è facoltativa per le applicazioni in produzione. Gli indirizzi non validi causano rimbalzi, quelli usa e getta favoriscono gli abusi e le liste non verificate danneggiano la reputazione del mittente.
I modelli di integrazione illustrati in questa guida coprono i casi d'uso più comuni. Copia il codice, adattalo al tuo stack e inizia a verificare ogni email che entra nel tuo sistema.
Pronto per l'integrazione? Ottieni la tua chiave API gratuita: 100 verifiche incluse.
