Real-Time Email Verification API
Verify any email address in under 100ms — fast enough to validate while the user is still on the form. Seven checks in parallel, one structured result.
What Mailbeam checks
Every verification runs 7 checks in parallel and returns a structured result in under 100ms.
p99 response time under 100ms
MX records for common EU and US domains are pre-warmed in Mailbeam's cache. Most verifications complete in 40–80ms. Worst-case (cold domain, slow mail server) stays under 500ms.
Seven checks run in parallel
Syntax, MX, SMTP probe, disposable detection, role detection and catch-all identification execute concurrently — not sequentially.
Typo suggestions in the response
When a user types 'gmal.com', the response includes `suggestion: 'gmail.com'`. Show it inline before the form submits — recover the lead instead of losing it.
Structured JSON result
A single response object includes `valid`, `score` (0–100), `status`, `disposable`, `role`, `suggestion`, and per-check booleans. One call, all the data you need.
Sandbox mode for testing
Use @valid.mailbeam-test.dev and @invalid.mailbeam-test.dev email domains in tests. Verification calls return deterministic results without using your quota.
EU-hosted, GDPR-compliant
All verification runs in Frankfurt, Germany. Email addresses are not stored after a real-time check; batch lists and results are kept for 72 hours, then deleted. Appropriate for processing EU user data under GDPR Article 28.
How it works
POST the email on form submission
Send the email address to /v1/verify in a POST request from your backend signup handler. Do not call the API from the browser — keep your API key server-side.
Parallel checks execute
Syntax validation, MX record lookup (from cache if available), SMTP mailbox probe, disposable database check, role prefix detection and catch-all detection run concurrently.
Result arrives in under 100ms
For cached domains, the full response — including AI score — returns in 40–80ms. The user experiences no perceptible delay.
Respond to the user inline
Use the `valid` boolean to accept or reject the submission. Use `suggestion` to show a correction prompt. Use `score` to apply your own quality threshold for edge cases.
Integrate in minutes
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("did you mean %s?", *result.Suggestion)
}
return fmt.Errorf("invalid email address")
}
if result.Disposable {
return fmt.Errorf("temporary email addresses are not accepted")
}
return nil
}When to use it
User registration forms
Block fake and mistyped emails before they enter your user database. Catch disposable addresses and show typo corrections inline.
E-commerce checkout email fields
Ensure order confirmation emails reach the customer. A 100ms check at checkout prevents the most common cause of 'I never got my order confirmation' support tickets.
Newsletter and waitlist signups
Protect list quality from day one. A real-time check at signup ensures every subscriber email is deliverable before it enters your sending platform.
B2B demo request forms
Block role-based and disposable emails on high-value conversion forms. Use the `role` flag to route info@ addresses to manual review instead of automated sequences.
Frequently asked questions
Will the verification slow down my signup form?
No. At p99 under 100ms, the verification completes faster than the network round-trip for most form submissions. Users do not perceive any additional delay.
Should I verify on the frontend or backend?
Always call the API from your backend — never from browser-side JavaScript. This keeps your API key secret and ensures the check cannot be bypassed by a client-side script.
What should I do if Mailbeam returns 'unknown' status?
Unknown means Mailbeam could not determine deliverability with confidence — typically because the mail server blocks SMTP probes (common with Google and Microsoft). The `score` field provides a confidence indicator. For unknown addresses with score ≥ 50, consider allowing signup and monitoring for bounces.
Can I use real-time verification alongside email confirmation links?
Yes, and we recommend it. Real-time verification catches typos and disposable emails immediately. Email confirmation links verify that the user controls the inbox. Use both for the highest-quality user base.
Ready to integrate?
Free tier includes 1,000 verifications/month. No credit card required.