Validate Email on Signup

Verify whether an email address is real and deliverable at the point of registration using the Veille email validation API — including syntax, DNS, and mailbox checks.

Overview

This playbook shows how to run a full email validation before accepting a signup: syntax check, DNS/MX record lookup, and SMTP reachability. The API returns a risk_score (0 = clean, 100 = high risk) that you can use to route users to extra verification steps.

Prerequisites

A Veille API key — get one at app.veille.io
Install dependencies for your language:

pip install requests

No extra dependencies — uses the native fetch API (Node 18+).

curl extension enabled (on by default).

No extra dependencies — uses net/http (Go 1.18+).

No extra dependencies — uses java.net.http (Java 11+).

No extra dependencies — uses System.Net.Http (.NET 6+).

# Cargo.toml
[dependencies]
reqwest = { version = "0.12", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde_json = "1"

Steps

Validate an email address

Call GET /v1/email with the email parameter.

import requests

API_KEY  = "YOUR_API_KEY"
response = requests.get(
    "https://api.veille.io/v1/email",
    headers={"x-api-key": API_KEY},
    params={"email": "alice@example.com"},
)
result = response.json()
print(result)

const API_KEY = "YOUR_API_KEY";

const params   = new URLSearchParams({ email: "alice@example.com" });
const response = await fetch(`https://api.veille.io/v1/email?${params}`, {
  headers: { "x-api-key": API_KEY },
});
const result = await response.json();
console.log(result);

<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["email" => "alice@example.com"]);

$ch = curl_init("https://api.veille.io/v1/email?{$params}");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
$result = json_decode(curl_exec($ch), true);
curl_close($ch);
print_r($result);

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    params := url.Values{"email": {"alice@example.com"}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/email?"+params.Encode(), nil)
    req.Header.Set("x-api-key", "YOUR_API_KEY")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)

    var result map[string]any
    json.Unmarshal(body, &result)
    fmt.Println(result)
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;

var client  = HttpClient.newHttpClient();
var email   = URLEncoder.encode("alice@example.com", StandardCharsets.UTF_8);
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.veille.io/v1/email?email=" + email))
    .header("x-api-key", "YOUR_API_KEY")
    .GET().build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

using System.Net.Http;

using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", "YOUR_API_KEY");

var email = Uri.EscapeDataString("alice@example.com");
var body  = await client.GetStringAsync($"https://api.veille.io/v1/email?email={email}");
Console.WriteLine(body);

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let result = reqwest::Client::new()
        .get("https://api.veille.io/v1/email")
        .header("x-api-key", "YOUR_API_KEY")
        .query(&[("email", "alice@example.com")])
        .send().await?.json::<serde_json::Value>().await?;

    println!("{:#?}", result);
    Ok(())
}

Interpret the result

Key fields: is_valid, is_deliverable, is_disposable, is_role_account, risk_score, did_you_mean (typo suggestion).

print(f"Valid       : {result['is_valid']}")
print(f"Deliverable : {result['is_deliverable']}")
print(f"Disposable  : {result['is_disposable']}")
print(f"Role account: {result['is_role_account']}")
print(f"Risk score  : {result['risk_score']}/100")
if result.get("did_you_mean"):
    print(f"Did you mean: {result['did_you_mean']}?")

console.log(`Valid       : ${result.is_valid}`);
console.log(`Deliverable : ${result.is_deliverable}`);
console.log(`Disposable  : ${result.is_disposable}`);
console.log(`Role account: ${result.is_role_account}`);
console.log(`Risk score  : ${result.risk_score}/100`);
if (result.did_you_mean) console.log(`Did you mean: ${result.did_you_mean}?`);

echo "Valid       : " . ($result["is_valid"]       ? "true" : "false") . "\n";
echo "Deliverable : " . ($result["is_deliverable"]  ? "true" : "false") . "\n";
echo "Disposable  : " . ($result["is_disposable"]   ? "true" : "false") . "\n";
echo "Risk score  : {$result['risk_score']}/100\n";
if (!empty($result["did_you_mean"])) echo "Did you mean: {$result['did_you_mean']}?\n";

fmt.Printf("Valid       : %v\nDeliverable : %v\nDisposable  : %v\nRisk score  : %v/100\n",
    result["is_valid"], result["is_deliverable"], result["is_disposable"], result["risk_score"])
if typo, ok := result["did_you_mean"].(string); ok && typo != "" {
    fmt.Println("Did you mean:", typo+"?")
}

import org.json.*;

var r = new JSONObject(response.body());
System.out.printf("Valid       : %b%nDeliverable : %b%nDisposable  : %b%nRisk score  : %d/100%n",
    r.getBoolean("is_valid"), r.getBoolean("is_deliverable"),
    r.getBoolean("is_disposable"), r.getInt("risk_score"));
if (r.has("did_you_mean")) System.out.println("Did you mean: " + r.getString("did_you_mean") + "?");

using System.Text.Json;

var r = JsonDocument.Parse(body).RootElement;
Console.WriteLine($"Valid       : {r.GetProperty("is_valid").GetBoolean()}");
Console.WriteLine($"Deliverable : {r.GetProperty("is_deliverable").GetBoolean()}");
Console.WriteLine($"Disposable  : {r.GetProperty("is_disposable").GetBoolean()}");
Console.WriteLine($"Risk score  : {r.GetProperty("risk_score").GetInt32()}/100");
if (r.TryGetProperty("did_you_mean", out var typo) && typo.GetString() is { } t and not "")
    Console.WriteLine($"Did you mean: {t}?");

println!("Valid       : {}", result["is_valid"]);
println!("Deliverable : {}", result["is_deliverable"]);
println!("Disposable  : {}", result["is_disposable"]);
println!("Risk score  : {}/100", result["risk_score"]);
if let Some(typo) = result["did_you_mean"].as_str() {
    if !typo.is_empty() { println!("Did you mean: {}?", typo); }
}

Build a risk-tiered registration flow

Use risk_score to route users: block high-risk addresses, prompt typo corrections, and apply extra friction to role accounts.

import requests

API_KEY = "YOUR_API_KEY"

def validate_email(email: str) -> dict:
    r = requests.get("https://api.veille.io/v1/email",
        headers={"x-api-key": API_KEY}, params={"email": email})
    return r.json()

def register(email: str) -> dict:
    v = validate_email(email)

    if not v.get("is_valid"):
        return {"ok": False, "error": "This email address is invalid."}

    if v.get("is_disposable"):
        return {"ok": False, "error": "Temporary email addresses are not accepted."}

    if v.get("did_you_mean"):
        return {"ok": False, "suggestion": f"Did you mean {v['did_you_mean']}?"}

    if v.get("risk_score", 0) >= 70:
        return {"ok": False, "error": "This email has a high risk score. Please use a different address."}

    if v.get("is_role_account"):
        # Allow but flag for manual review
        return {"ok": True, "flag": "role_account", "message": "Please verify your email."}

    return {"ok": True, "message": "Registration successful!"}

for test_email in ["alice@mailinator.com", "info@company.com", "alice@gmial.com", "alice@stripe.com"]:
    print(f"{test_email}: {register(test_email)}")

const API_KEY = "YOUR_API_KEY";

async function validateEmail(email: string) {
  const params = new URLSearchParams({ email });
  const res    = await fetch(`https://api.veille.io/v1/email?${params}`, {
    headers: { "x-api-key": API_KEY },
  });
  return res.json();
}

async function register(email: string) {
  const v = await validateEmail(email);
  if (!v.is_valid)       return { ok: false, error: "Invalid email address." };
  if (v.is_disposable)   return { ok: false, error: "Temporary emails not accepted." };
  if (v.did_you_mean)    return { ok: false, suggestion: `Did you mean ${v.did_you_mean}?` };
  if (v.risk_score >= 70) return { ok: false, error: "High risk score — please use another address." };
  if (v.is_role_account) return { ok: true,  flag: "role_account", message: "Please verify your email." };
  return { ok: true, message: "Registration successful!" };
}

for (const email of ["alice@mailinator.com", "info@company.com", "alice@gmial.com", "alice@stripe.com"]) {
  console.log(email, await register(email));
}

<?php
function validateEmail(string $apiKey, string $email): array {
    $params = http_build_query(["email" => $email]);
    $ch = curl_init("https://api.veille.io/v1/email?{$params}");
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, ["x-api-key: {$apiKey}"]);
    $result = json_decode(curl_exec($ch), true);
    curl_close($ch);
    return $result;
}

function register(string $apiKey, string $email): array {
    $v = validateEmail($apiKey, $email);
    if (!($v["is_valid"]      ?? false)) return ["ok" => false, "error" => "Invalid email."];
    if ($v["is_disposable"]   ?? false)  return ["ok" => false, "error" => "Temporary emails not accepted."];
    if (!empty($v["did_you_mean"]))      return ["ok" => false, "suggestion" => "Did you mean {$v['did_you_mean']}?"];
    if (($v["risk_score"]     ?? 0) >= 70) return ["ok" => false, "error" => "High risk score."];
    if ($v["is_role_account"] ?? false)  return ["ok" => true,  "flag" => "role_account"];
    return ["ok" => true, "message" => "Registration successful!"];
}

foreach (["alice@mailinator.com", "info@company.com", "alice@gmial.com"] as $email) {
    print_r(["email" => $email, "result" => register("YOUR_API_KEY", $email)]);
}

package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
)

const APIKey = "YOUR_API_KEY"

func validate(email string) map[string]any {
    params := url.Values{"email": {email}}
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/email?"+params.Encode(), nil)
    req.Header.Set("x-api-key", APIKey)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var v map[string]any
    json.Unmarshal(body, &v)
    return v
}

func register(email string) string {
    v := validate(email)
    if !(v["is_valid"].(bool))    { return "❌ Invalid email." }
    if v["is_disposable"].(bool)  { return "❌ Disposable not accepted." }
    if typo, ok := v["did_you_mean"].(string); ok && typo != "" {
        return "⚠️  Did you mean " + typo + "?"
    }
    if v["risk_score"].(float64) >= 70 { return "❌ High risk score." }
    return "✅ Registration successful!"
}

func main() {
    for _, email := range []string{"alice@mailinator.com", "info@company.com", "alice@stripe.com"} {
        fmt.Printf("%s: %s\n", email, register(email))
    }
}

import java.net.URI;
import java.net.URLEncoder;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import org.json.*;

public class Main {
    static HttpClient client = HttpClient.newHttpClient();
    static String API_KEY   = "YOUR_API_KEY";

    static JSONObject validate(String email) throws Exception {
        var encoded = URLEncoder.encode(email, StandardCharsets.UTF_8);
        var req     = HttpRequest.newBuilder()
            .uri(URI.create("https://api.veille.io/v1/email?email=" + encoded))
            .header("x-api-key", API_KEY).GET().build();
        var resp    = client.send(req, HttpResponse.BodyHandlers.ofString());
        return new JSONObject(resp.body());
    }

    static String register(String email) throws Exception {
        var v = validate(email);
        if (!v.getBoolean("is_valid"))      return "❌ Invalid email.";
        if (v.getBoolean("is_disposable"))  return "❌ Disposable not accepted.";
        if (v.has("did_you_mean"))          return "⚠️  Did you mean " + v.getString("did_you_mean") + "?";
        if (v.getInt("risk_score") >= 70)   return "❌ High risk score.";
        return "✅ Registration successful!";
    }

    public static void main(String[] args) throws Exception {
        for (var email : new String[]{"alice@mailinator.com", "info@company.com", "alice@stripe.com"}) {
            System.out.printf("%s: %s%n", email, register(email));
        }
    }
}

using System.Net.Http;
using System.Text.Json;

var apiKey = "YOUR_API_KEY";
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("x-api-key", apiKey);

async Task<JsonElement> Validate(string email)
{
    var encoded = Uri.EscapeDataString(email);
    var body    = await client.GetStringAsync($"https://api.veille.io/v1/email?email={encoded}");
    return JsonDocument.Parse(body).RootElement;
}

async Task<string> Register(string email)
{
    var v = await Validate(email);
    if (!v.GetProperty("is_valid").GetBoolean())                      return "❌ Invalid email.";
    if (v.GetProperty("is_disposable").GetBoolean())                  return "❌ Disposable not accepted.";
    if (v.TryGetProperty("did_you_mean", out var t) && t.GetString() is { Length: > 0 } typo)
                                                                      return $"⚠️  Did you mean {typo}?";
    if (v.GetProperty("risk_score").GetInt32() >= 70)                 return "❌ High risk score.";
    return "✅ Registration successful!";
}

foreach (var email in new[] { "alice@mailinator.com", "info@company.com", "alice@stripe.com" })
    Console.WriteLine($"{email}: {await Register(email)}");

use reqwest::Client;
use serde_json::Value;

const API_KEY: &str = "YOUR_API_KEY";

async fn validate(client: &Client, email: &str) -> Value {
    client.get("https://api.veille.io/v1/email")
        .header("x-api-key", API_KEY)
        .query(&[("email", email)])
        .send().await.unwrap().json::<Value>().await.unwrap()
}

async fn register(client: &Client, email: &str) -> &'static str {
    let v = validate(client, email).await;
    if !v["is_valid"].as_bool().unwrap_or(false)     { return "❌ Invalid email."; }
    if  v["is_disposable"].as_bool().unwrap_or(false) { return "❌ Disposable not accepted."; }
    if  v["risk_score"].as_i64().unwrap_or(0) >= 70  { return "❌ High risk score."; }
    "✅ Registration successful!"
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client = Client::new();
    for email in ["alice@mailinator.com", "info@company.com", "alice@stripe.com"] {
        println!("{}: {}", email, register(&client, email).await);
    }
    Ok(())
}

Role accounts (admin@, info@, support@) are often monitored by multiple people — or not monitored at all. Flag them for manual review rather than blocking outright to avoid losing legitimate B2B signups.