Beta privataMailbeam è in beta privata: l'API pubblica non è ancora aperta.Iscriviti alla lista d'attesa

Mailbeam
API · Tempo reale

API di verifica email in tempo reale

Verifica qualsiasi indirizzo in meno di 100 ms, abbastanza in fretta da validare mentre l'utente è ancora nel modulo. Sette controlli in parallelo, un unico risultato strutturato.

Che cosa controlla Mailbeam

Ogni verifica esegue 7 controlli in parallelo e restituisce un risultato strutturato in meno di 100 ms.

Tempo di risposta p99 sotto i 100 ms

I record MX dei domini europei e statunitensi più comuni sono preriscaldati nella cache di Mailbeam. La maggior parte delle verifiche finisce in 40-80 ms. Nel caso peggiore (dominio freddo, server lento) resta sotto i 500 ms.

Sette controlli in parallelo

Sintassi, MX, sondaggio SMTP, rilevamento degli usa e getta, rilevamento del ruolo e identificazione del catch-all girano in modo concorrente, non sequenziale.

Suggerimenti sui refusi nella risposta

Quando un utente scrive «gmal.com», la risposta include `suggestion: 'gmail.com'`. Mostralo in linea prima che il modulo venga inviato e recupera il lead invece di perderlo.

Risultato JSON strutturato

Un unico oggetto di risposta include `valid`, `score` (0-100), `status`, `disposable`, `role`, `suggestion` e un booleano per controllo. Una chiamata, tutti i dati che ti servono.

Modalità sandbox per i test

Usa i domini @valid.mailbeam-test.dev e @invalid.mailbeam-test.dev nei tuoi test. Le chiamate di verifica restituiscono risultati deterministici senza consumare quota.

Ospitata nell'UE, conforme al GDPR

Tutta la verifica gira a Francoforte, in Germania. Gli indirizzi non vengono conservati dopo un controllo in tempo reale; le liste e i risultati dei lotti restano 72 ore e poi vengono cancellati. Adatta a trattare dati di utenti europei ai sensi dell'articolo 28 del GDPR.

Come funziona

1

Fai POST dell'email all'invio del modulo

Invia l'indirizzo a /v1/verify con una richiesta POST dal gestore di registrazione del tuo backend. Non chiamare l'API dal browser: tieni la tua API key sul server.

2

I controlli girano in parallelo

La validazione della sintassi, la query dei record MX (dalla cache se disponibile), il sondaggio SMTP della casella, il confronto con il database degli usa e getta, il rilevamento dei prefissi di ruolo e il rilevamento del catch-all girano in modo concorrente.

3

Il risultato arriva in meno di 100 ms

Per i domini in cache, la risposta completa — punteggio dell'IA compreso — torna in 40-80 ms. L'utente non percepisce alcun ritardo.

4

Rispondi all'utente in linea

Usa il booleano `valid` per accettare o rifiutare l'invio. Usa `suggestion` per mostrare una proposta di correzione. Usa `score` per applicare la tua soglia di qualità nei casi limite.

Integralo in pochi minuti

GoGo
package main

import (
  "bytes"
  "encoding/json"
  "fmt"
  "net/http"
  "os"
)

type VerifyRequest struct {
  Email string `json:"email"`
}

type VerifyResult struct {
  Valid       bool    `json:"valid"`
  Score       int     `json:"score"`
  Disposable  bool    `json:"disposable"`
  Role        bool    `json:"role"`
  Suggestion  *string `json:"suggestion"`
  Status      string  `json:"status"`
}

func verifyEmail(email string) (*VerifyResult, error) {
  body, _ := json.Marshal(VerifyRequest{Email: email})
  req, _ := http.NewRequest("POST", "https://api.mailbeam.dev/v1/verify", bytes.NewReader(body))
  req.Header.Set("Authorization", "Bearer "+os.Getenv("MAILBEAM_KEY"))
  req.Header.Set("Content-Type", "application/json")

  resp, err := http.DefaultClient.Do(req)
  if err != nil {
    return nil, err
  }
  defer resp.Body.Close()

  var result VerifyResult
  json.NewDecoder(resp.Body).Decode(&result)
  return &result, nil
}

func handleSignup(email string) error {
  result, err := verifyEmail(email)
  if err != nil || !result.Valid {
    if result != nil && result.Suggestion != nil {
      return fmt.Errorf("intendevi %s?", *result.Suggestion)
    }
    return fmt.Errorf("indirizzo email non valido")
  }
  if result.Disposable {
    return fmt.Errorf("gli indirizzi email temporanei non sono ammessi")
  }
  return nil
}

Quando usarlo

Moduli di registrazione degli utenti

Blocca le email false e scritte male prima che entrino nella tua base utenti. Intercetta gli indirizzi usa e getta e mostra correzioni dei refusi in linea.

Campi email del checkout e-commerce

Assicurati che la conferma dell'ordine arrivi al cliente. Un controllo da 100 ms al checkout evita la causa più comune dei ticket del tipo «non mi è arrivata la conferma».

Iscrizioni a newsletter e liste d'attesa

Proteggi la qualità della lista dal primo giorno. Un controllo in tempo reale all'iscrizione garantisce che ogni iscritto sia recapitabile prima di entrare nella tua piattaforma di invio.

Moduli di richiesta demo B2B

Blocca gli indirizzi di ruolo e usa e getta nei moduli di conversione di maggior valore. Usa la marcatura `role` per instradare gli indirizzi info@ alla revisione manuale invece che a sequenze automatizzate.

Domande frequenti

Pronto a integrarlo?

Il piano gratuito include 1.000 verifiche al mese. Senza carta di credito.