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.

Handler di iscrizione nel backendDecisione del modulo
// 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.

1

Controllo della sintassi

Trova errori di battitura, TLD mancanti, punteggiatura non ammessa e spazi prima di qualsiasi lookup di rete esterno.

2

Verifica DNS e MX

Controlla che il dominio sia registrato e trova i server di posta configurati che possono accettare messaggi in arrivo.

3

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 APICondizione del campoCosa deve fare il modulo
Non validastatus === "undeliverable"Blocca subito. Mostra: "Inserisci un indirizzo email valido e attivo."
Usa e gettadetails.attributes.disposable === trueBlocca o chiedi un altro indirizzo. Mostra: "Gli indirizzi email temporanei non sono ammessi."
Account di ruolodetails.attributes.role_account === trueAccetta; segnala nei moduli B2B. Avvisa gli account manager o invia al gruppo dei lead generici.
Email gratuitadetails.attributes.free_email === trueAccetta nelle app B2C; richiedi un'email aziendale nei moduli B2B per demo o prove.
Catch-alldetails.attributes.catch_all === trueControlla catch_all_verdict: se "valid" accetta; se "invalid" blocca; se null accetta l'iscrizione.
Sconosciutastatus === "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.

1

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.

2

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.

3

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.

4

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

Backend: Node.js (route Express)solo lato server
// 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 });
});
Backend: Python (route Flask)solo lato server
# 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: client nel browser (chiama il tuo backend)script lato client
// 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 JSONTipoUso in iscrizione
data.is_validbooleanControllo booleano rapido. È true quando i controlli del dominio e della casella sono superati.
data.statusstringStato di consegna principale: "deliverable", "undeliverable", "unknown".
data.deliverability_scorenumber (0-100)Punteggio di qualità basato sulle risposte della casella, sulla stabilità dei server MX e sui controlli di reputazione.
data.details.attributes.disposablebooleanÈ true quando il dominio è un servizio noto di caselle temporanee o usa e getta.
data.details.attributes.free_emailbooleanÈ true per i provider per privati (Gmail, Outlook). Richiedi domini aziendali nei moduli B2B.
data.details.attributes.role_accountbooleanÈ true per gli indirizzi di organizzazione come info@, admin@ o support@.
data.catch_all_verdict"valid" | "invalid" | nullRisoluzione 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.

Crediti
3.000crediti
Prezzo0,0017 $ / credito
Risparmio
-
Totale
5,00 $una tantum
Crediti
10.000crediti
Prezzo0,0010 $ / credito
Risparmio
Risparmi il 41%
Totale
9,90 $una tantum
Crediti
30.000crediti
Prezzo0,0009 $ / credito
Risparmio
Risparmi il 44%
Totale
28,00 $una tantum
Crediti
50.000crediti
Prezzo0,0008 $ / credito
Risparmio
Risparmi il 53%
Totale
39,00 $una tantum
Crediti
100.000creditiPiù scelto
Prezzo0,0008 $ / credito
Risparmio
Risparmi il 54%
Totale
76,00 $una tantum
Crediti
300.000crediti
Prezzo0,0007 $ / credito
Risparmio
Risparmi il 56%
Totale
222,00 $una tantum
Crediti
500.000crediti
Prezzo0,0007 $ / credito
Risparmio
Risparmi il 57%
Totale
360,00 $una tantum
Crediti
800.000crediti
Prezzo0,0007 $ / credito
Risparmio
Risparmi il 58%
Totale
559,00 $una tantum
Crediti
1.000.000crediti
Prezzo0,0007 $ / credito
Risparmio
Risparmi il 59%
Totale
680,00 $una tantum

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.

Prova gratuita I crediti non scadono Rimborso sugli Sconosciuti