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

Mailbeam
API · Validazione

API di validazione della sintassi delle email

Un'espressione regolare nel browser intercetta gli errori evidenti. La validazione RFC 5322 sul server intercetta i casi limite, e non si può aggirare.

Che cosa controlla Mailbeam

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

Analisi conforme alla RFC 5322

Mailbeam valida la sintassi dell'email secondo lo standard RFC 5322. Questo comprende parti locali tra virgolette, caratteri internazionalizzati e formati poco comuni ma validi che la maggior parte delle espressioni regolari rifiuta per errore.

Normalizzazione dell'email

La risposta include un campo `normalized_email`: dominio in minuscolo, spazi rimossi e formato coerente. Salva la versione normalizzata per evitare account duplicati con lo stesso indirizzo.

Suggerimento sui refusi

Gli errori di dominio più comuni (gmal.com, hotmal.com, outlok.com) vengono rilevati e viene restituito un suggerimento corretto. Mostralo nella tua interfaccia prima che l'utente invii il modulo.

Booleano syntax_check

Il booleano `syntax_check` della risposta isola l'esito della sintassi dal composto `valid`. Usalo per distinguere un errore di sintassi da uno di MX o SMTP nella tua gestione degli errori.

Fallimento immediato in caso di sintassi non valida

Quando la validazione della sintassi fallisce, Mailbeam restituisce subito l'esito: non viene fatta alcuna chiamata DNS o SMTP. Questo rende il fallimento di sintassi la risposta più rapida possibile, sotto i 5 ms.

Applicazione lato server che non si può aggirare

La validazione nel browser si disattiva spegnendo JavaScript o usando gli strumenti per sviluppatori. La validazione della sintassi lato server tramite API garantisce che ogni indirizzo salvato nel tuo database rispetti la RFC.

Come funziona

1

Si analizza la stringa dell'email

L'email viene divisa in parte locale (prima della chiocciola) e dominio (dopo). Ogni parte viene validata in modo indipendente secondo le regole della RFC 5322.

2

Si esegue il rilevamento dei refusi

Il dominio viene confrontato con un dizionario di domini di posta legittimi comuni. Se esiste una correzione ad alta probabilità (distanza di edit di 2 o meno), viene generato un suggerimento.

3

Si applica la normalizzazione

Il dominio viene portato in minuscolo, gli spazi vengono rimossi e la stringa normalizzata viene restituita nella risposta. Le etichette del segno più vengono conservate (non eliminate) nella normalizzazione.

4

Ritorno anticipato o catena completa

Se la sintassi fallisce, Mailbeam restituisce subito l'esito con `syntax_check: false`. Se passa, gli altri controlli (MX, SMTP, usa e getta, ecc.) proseguono in parallelo.

Integralo in pochi minuti

Java (Spring Boot)Java
import java.net.http.*;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

@Service
public class EmailValidationService {

    private final HttpClient http = HttpClient.newHttpClient();
    private final ObjectMapper mapper = new ObjectMapper();
    private final String apiKey = System.getenv("MAILBEAM_KEY");

    public ValidationResult validate(String email) throws Exception {
        String body = mapper.writeValueAsString(Map.of("email", email));

        HttpRequest req = HttpRequest.newBuilder()
            .uri(URI.create("https://api.mailbeam.dev/v1/verify"))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> resp = http.send(req, HttpResponse.BodyHandlers.ofString());
        JsonNode result = mapper.readTree(resp.body());

        if (!result.get("syntax_check").asBoolean()) {
            String suggestion = result.has("suggestion") && !result.get("suggestion").isNull()
                ? result.get("suggestion").asText() : null;
            throw new InvalidEmailException("Formato email non valido.", suggestion);
        }

        return new ValidationResult(
            result.get("valid").asBoolean(),
            result.get("score").asInt(),
            result.get("normalized_email").asText()
        );
    }
}

Quando usarlo

Validazione dell'input nelle API di servizio

Nelle architetture a microservizi, valida i campi email a ogni confine di API. Un controllo di sintassi sul gateway impedisce ai dati malformati di propagarsi nel tuo sistema.

Bonifica degli import nel database

Quando importi dati email da fonti esterne (CSV, sistemi legacy, strumenti di terze parti), un controllo di sintassi individua le voci malformate prima che entrino nel tuo database.

Rafforzamento del modulo di registrazione

Combina una validazione leggera nel browser per l'esperienza utente con l'applicazione autoritativa sul server. Il controllo del server intercetta ciò che sfugge al client e non si può aggirare.

Audit sulla qualità dei dati

Sui database con dati email storici, lancia un controllo di sintassi in blocco per individuare e segnalare i record che non rispettano la RFC 5322: è spesso un prerequisito per la conformità alla qualità dei dati del GDPR.

Domande frequenti

Pronto a integrarlo?

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