API di validazione email in tempo reale per i moduli di iscrizione
Valida gli indirizzi nel momento in cui gli utenti li inviano: server di posta ed esistenza della casella in una sola chiamata, con gli indicatori usa e getta e di ruolo per decidere cosa accettare. La nostra API di validazione email blocca i dati sbagliati prima che entrino e tiene gli account falsi fuori dal tuo database.
// 1. Receive submitted form data
const { email } = req.body;
// 2. Validate via API
const { data } = await checkEmail(email);
// 3. Make real-time form decision
if (data.status === 'undeliverable') {
return res.status(400).json({ error: 'Please enter a valid, active email address.' });
}
if (data.details.attributes.disposable) {
return res.status(400).json({ error: 'Temporary or disposable emails are not allowed.' });
}
// 4. Proceed with account registration
await createUser({ email });1.000 crediti gratuiti, senza carta. I crediti non scadono mai.
Perché una regex da sola non è validazione email
Un'espressione regolare controlla solo la struttura del testo: se c'è una @, se il formato del dominio sembra plausibile e se i caratteri rientrano negli intervalli ASCII standard. La regex dice solo se un input sembra un indirizzo email, non se qualcuno può ricevere messaggi lì.
Scrivere user@example.com o asdf12345@gmail.com supera senza problemi qualsiasi regex conforme agli RFC. Eppure uno dei due domini può non avere server di posta attivi, e l'altra casella può non esistere.
La nostra API di validazione email con risposta JSON va molto oltre le espressioni regolari. In una sola richiesta controlla i record DNS, esegue il lookup dei server MX, si collega al server di posta di destinazione per verificare se la casella risponde e confronta il dominio con ampie liste di domini usa e getta.
I pattern regex rigidi causano anche falsi rifiuti. Le espressioni personalizzate spesso rifiutano domini di primo livello poco comuni come .studio o .cloud, caratteri internazionali validi o indirizzi legittimi con punteggiatura insolita. La nostra API gestisce in automatico tutta la sintassi RFC 5322, così non devi mantenere fragili librerie regex nel tuo codice.
Controllo della sintassi
Trova errori di battitura, TLD mancanti, punteggiatura non ammessa e spazi prima di qualsiasi lookup di rete esterno.
Verifica DNS e MX
Controlla che il dominio sia registrato e trova i server di posta configurati che possono accettare messaggi in arrivo.
Controllo della casella
Comunica direttamente con il server di posta remoto per confermare se quella casella esiste e può ricevere posta.
Cosa bloccare, segnalare o accettare in fase di iscrizione
Ogni attività ha requisiti di iscrizione diversi. Un SaaS B2B per aziende può richiedere email aziendali, mentre un'app social per privati accetta indirizzi Gmail personali. Ecco la tabella decisionale consigliata, basata sugli attributi reali della risposta API:
| Risultato API | Condizione del campo | Cosa deve fare il modulo |
|---|---|---|
| Non valida | status === "undeliverable" | Blocca subito. Mostra: "Inserisci un indirizzo email valido e attivo." |
| Usa e getta | details.attributes.disposable === true | Blocca o chiedi un altro indirizzo. Mostra: "Gli indirizzi email temporanei non sono ammessi." |
| Account di ruolo | details.attributes.role_account === true | Accetta; segnala nei moduli B2B. Avvisa gli account manager o invia al gruppo dei lead generici. |
| Email gratuita | details.attributes.free_email === true | Accetta nelle app B2C; richiedi un'email aziendale nei moduli B2B per demo o prove. |
| Catch-all | details.attributes.catch_all === true | Controlla catch_all_verdict: se "valid" accetta; se "invalid" blocca; se null accetta l'iscrizione. |
| Sconosciuta | status === "unknown" | Accetta e ricontrolla più tardi (rimborsata). In caso di errore lascia passare (fail-open), così non blocchi mai gli utenti reali. |
Aggiungi la validazione email al tuo modulo di iscrizione
Segui questa sequenza in quattro passaggi per integrare la validazione in tempo reale in modo sicuro. Le richieste usano la tua chiave API privata, quindi esegui il controllo dal tuo server backend.
Perché conta il modello fail-open: i moduli di iscrizione sono sensibili ai ritardi. Se una chiamata a un'API esterna subisce latenza di rete, bloccare il modulo può farti perdere un cliente reale. Con un timeout breve e l'iscrizione che prosegue in automatico, gli utenti reali non vengono respinti, e il backend mette l'indirizzo in coda per un controllo successivo in background.
Il modulo invia i dati al backend
Quando un visitatore invia i dati di iscrizione, il browser trasmette l'indirizzo email all'endpoint della tua applicazione.
Il backend chiama l'API di validazione
Il tuo server invia una richiesta POST sincrona a Giggal con la chiave privata salvata in una variabile d'ambiente.
Il backend applica la tabella decisionale
Leggi gli attributi del JSON. Se l'email è usa e getta o non consegnabile, rimanda al browser un messaggio di errore chiaro.
Lascia passare in caso di timeout
Se la comunicazione con l'API va in timeout, applica il fail-open: accetta l'iscrizione e metti in coda un job in background per verificarla più tardi.
Esempi di codice di implementazione
// server.js (Express Route)
const timeoutMs = 5000; // adjust to what your form can tolerate
app.post('/api/signup', async (req, res) => {
const { email, password } = req.body;
try {
const apiRes = await fetch('https://api.giggal.ai/v1/verify', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.GIGGAL_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({ email }),
signal: AbortSignal.timeout(timeoutMs), // fail-open timeout
});
const result = await apiRes.json();
if (result.success) {
const { status, details } = result.data;
// Decision checks
if (status === 'undeliverable') {
return res.status(400).json({ error: 'This email address does not exist.' });
}
if (details.attributes.disposable) {
return res.status(400).json({ error: 'Disposable email addresses are not accepted.' });
}
}
} catch (err) {
// Fail open: log timeout and let user proceed
console.warn('Email check timed out, failing open:', err.message);
}
// Create user in database
const user = await db.users.create({ email, password });
return res.json({ success: true, userId: user.id });
});# app.py (Flask Route)
import os, requests
from flask import Flask, request, jsonify
app = Flask(__name__)
timeout_seconds = 5 # adjust to what your form can tolerate
@app.route("/api/signup", methods=["POST"])
def signup():
email = request.json.get("email")
try:
resp = requests.post(
"https://api.giggal.ai/v1/verify",
headers={"Authorization": f"Bearer {os.environ['GIGGAL_API_KEY']}"},
json={"email": email},
timeout=timeout_seconds # fail open on timeout
)
data = resp.json().get("data", {})
if data.get("status") == "undeliverable":
return jsonify({"error": "Email address is invalid."}), 400
if data.get("details", {}).get("attributes", {}).get("disposable"):
return jsonify({"error": "Disposable emails are prohibited."}), 400
except requests.exceptions.RequestException:
# Fail open: proceed with signup on timeout
pass
# Complete user registration
return jsonify({"success": True})// Frontend form submit handler
const form = document.querySelector('#signup-form');
form.addEventListener('submit', async (e) => {
e.preventDefault();
const email = document.querySelector('#email-input').value;
const res = await fetch('/api/signup', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ email }),
});
const payload = await res.json();
if (!res.ok) {
showFormError(payload.error); // Show friendly user feedback
} else {
redirectToDashboard();
}
});Importante: non chiamare mai l'endpoint dell'API Giggal direttamente da script lato client. Tieni le tue credenziali private sul tuo server.
Blocca le iscrizioni usa e getta e false
Le caselle temporanee falsano le analisi del tuo prodotto, consumano le quote delle prove gratuite e non diventano mai clienti paganti. Il nostro servizio controlla e segnala gli schemi di iscrizione ad alto rischio.
Caselle usa e getta
Controllate con il nostro registro aggiornato di oltre 100.000 domini temporanei. Scopri come riconosciamo le caselle usa e getta con la nostra verifica email temporanea.
Rilevamento degli alias con il più
Segnala gli alias creati con il segno più (user+trial@domain.com), così una stessa persona non può creare più account di prova.
Rilevamento delle caselle no-reply
Rileva le caselle automatiche e di invio massivo che scartano la posta in arrivo, così nessuno si iscrive con indirizzi che non rispondono.
Non correggere in automatico gli errori di battitura
Non modificare mai in silenzio ciò che scrive l'utente (per esempio cambiare gnail.com in gmail.com in automatico). Se un indirizzo non supera la validazione, mostra un messaggio chiaro perché l'utente controlli ciò che ha scritto. Se lo riscrivi in silenzio, rischi di inviare link di attivazione o ricevute di pagamento alla persona sbagliata.
Dove validare le email in tempo reale
Valida gli indirizzi email in ogni modulo del tuo prodotto in cui gli utenti inviano dati.
Moduli di registrazione
Previeni lo spam nelle registrazioni e aiuta le email di benvenuto e i link di verifica ad arrivare in caselle attive.
Checkout e-commerce
Fai arrivare ai clienti avvisi di spedizione, ricevute e conferme d'ordine senza errori di consegna.
Richieste di contatto e demo
Filtra le richieste false dei concorrenti e verifica i domini aziendali prima di passare i contatti ai commerciali.
Iscrizioni alla newsletter
Proteggi la reputazione del tuo dominio di invio: rifiuta gli indirizzi malformati e le iscrizioni dei bot al momento dell'opt-in.
Automazioni con webhook
Avvia la validazione in automatico dai webhook dei moduli con le nostre integrazioni Zapier e n8n.
Modifiche al profilo
Verifica i nuovi indirizzi quando gli utenti modificano il profilo o il contatto di fatturazione.
I campi della risposta che userai in fase di iscrizione
Un riepilogo dei campi JSON principali che servono per applicare la logica di validazione del modulo.
| Campo JSON | Tipo | Uso in iscrizione |
|---|---|---|
| data.is_valid | boolean | Controllo booleano rapido. È true quando i controlli del dominio e della casella sono superati. |
| data.status | string | Stato di consegna principale: "deliverable", "undeliverable", "unknown". |
| data.deliverability_score | number (0-100) | Punteggio di qualità basato sulle risposte della casella, sulla stabilità dei server MX e sui controlli di reputazione. |
| data.details.attributes.disposable | boolean | È true quando il dominio è un servizio noto di caselle temporanee o usa e getta. |
| data.details.attributes.free_email | boolean | È true per i provider per privati (Gmail, Outlook). Richiedi domini aziendali nei moduli B2B. |
| data.details.attributes.role_account | boolean | È true per gli indirizzi di organizzazione come info@, admin@ o support@. |
| data.catch_all_verdict | "valid" | "invalid" | null | Risoluzione dei domini catch-all nella stessa chiamata. Recupera i contatti validi senza scartarli. |
Per le definizioni complete degli endpoint, gli schemi dei parametri e i codici di errore, consulta la documentazione API completa.
Prezzi dell'API di validazione email
Paghi solo le validazioni che esegui, senza minimi mensili né vincoli. Ogni chiamata di validazione API consuma 1 credito, con i controlli catch-all inclusi nella stessa chiamata. I risultati sconosciuti vengono rimborsati in automatico e i primi 1.000 crediti sono del tutto gratuiti.
Vedi tutti i piani a volume e gli sconti degli abbonamenti mensili nella nostra pagina dei prezzi.
Domande frequenti sull'API di validazione email
Risposte alle domande più comuni sull'implementazione nei moduli di iscrizione e sulla validazione in tempo reale.
Sì. Ogni nuovo account riceve 1.000 crediti gratuiti alla registrazione, senza carta di credito. Puoi generare una chiave API nella dashboard sviluppatore e iniziare subito a provare la validazione dei moduli in tempo reale. I crediti gratuiti non scadono mai e danno accesso completo a tutti gli attributi e i controlli di validazione.
No. Chiamare l'API da JavaScript lato client esporrebbe la tua chiave API segreta a chiunque controlli le richieste di rete del browser. Invia sempre i dati del modulo prima al tuo server backend o a una funzione serverless, e fai inviare al tuo server la richiesta a https://api.giggal.ai/v1/verify.
Non viene mai inviato nessun messaggio. L'API controlla se la casella esiste. Chiude la connessione prima che venga trasmesso qualsiasi dato o contenuto dell'email, quindi i tuoi utenti non ricevono nulla nella posta in arrivo.
Sì. Ogni controllo confronta il dominio con il nostro registro di oltre 100.000 domini email usa e getta e temporanei. Se c'è una corrispondenza, details.attributes.disposable restituisce true e lo stato diventa undeliverable, così il tuo backend può bloccare gli account temporanei.
Dipende dal tuo modello di business. Nelle app per privati, account di ruolo come support@ o info@ possono appartenere a organizzazioni reali. Nei SaaS B2B self-service, dove serve sapere chi è ogni utente, molte aziende segnalano o non ammettono gli account di ruolo generici per evitare che le credenziali vengano condivise.
I domini catch-all accettano qualsiasi indirizzo di destinazione senza condizioni, quindi i controlli standard non danno una risposta certa. La nostra API esegue la verifica catch-all approfondita nella stessa chiamata per capire se la casella esiste. Se il controllo catch-all restituisce "valid", puoi accettare l'iscrizione in sicurezza; se restituisce "invalid", l'indirizzo rimbalzerà e l'iscrizione va fermata.
Consigliamo il modello fail-open. Se la chiamata del tuo backend va in timeout di rete o dà un errore di connessione, lascia completare l'iscrizione invece di bloccare un potenziale cliente. Metti l'indirizzo non validato nella coda del tuo worker in background per ricontrollare più tardi lo stato di consegna.
Scegli un'API di validazione email quando ti servono controlli in tempo reale nei moduli di iscrizione web, per fermare errori di battitura, caselle usa e getta e bot all'invio del modulo. Scegli un'API di verifica email quando devi controllare database di marketing esistenti, sincronizzare i contatti del CRM o pulire file di email in blocco prima di inviare campagne.
Proteggi oggi i tuoi moduli di iscrizione
1.000 crediti gratis, nessuna carta richiesta.
