Valider un email à l'inscription

Vérifiez si une adresse email est réelle et délivrable au moment de l'inscription avec l'API de validation email Veille — syntaxe, DNS et vérification de boîte aux lettres incluses.

Vue d'ensemble

Ce guide montre comment effectuer une validation complète d'email avant d'accepter une inscription : vérification de syntaxe, recherche DNS/MX et accessibilité SMTP. L'API retourne un risk_score (0 = propre, 100 = risque élevé) utilisable pour orienter les utilisateurs vers des étapes de vérification supplémentaires.

Prérequis

Une clé API Veille — obtenez-en une sur app.veille.io
Installez les dépendances pour votre langage :

pip install requests

Aucune dépendance supplémentaire — utilise l'API native fetch (Node 18+).

Extension curl activée (par défaut).

Aucune dépendance supplémentaire — utilise net/http (Go 1.18+).

Aucune dépendance supplémentaire — utilise java.net.http (Java 11+).

Aucune dépendance supplémentaire — utilise System.Net.Http (.NET 6+).

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

Étapes

Valider une adresse email

Appelez GET /v1/email avec le paramètre email.

import requests

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

const API_KEY = "YOUR_API_KEY";

const params   = new URLSearchParams({ email: "[email protected]" });
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" => "[email protected]"]);

$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": {"[email protected]"}}
    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("[email protected]", 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("[email protected]");
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", "[email protected]")])
        .send().await?.json::<serde_json::Value>().await?;

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

Interpréter le résultat

Champs clés : is_valid, is_deliverable, is_disposable, is_role_account, risk_score, did_you_mean (suggestion de faute de frappe).

print(f"Valide      : {result['is_valid']}")
print(f"Délivrable  : {result['is_deliverable']}")
print(f"Jetable     : {result['is_disposable']}")
print(f"Compte rôle : {result['is_role_account']}")
print(f"Score risque: {result['risk_score']}/100")
if result.get("did_you_mean"):
    print(f"Vouliez-vous dire : {result['did_you_mean']} ?")

console.log(`Valide      : ${result.is_valid}`);
console.log(`Délivrable  : ${result.is_deliverable}`);
console.log(`Jetable     : ${result.is_disposable}`);
console.log(`Compte rôle : ${result.is_role_account}`);
console.log(`Score risque: ${result.risk_score}/100`);
if (result.did_you_mean) console.log(`Vouliez-vous dire : ${result.did_you_mean} ?`);

echo "Valide      : " . ($result["is_valid"]       ? "true" : "false") . "\n";
echo "Délivrable  : " . ($result["is_deliverable"]  ? "true" : "false") . "\n";
echo "Jetable     : " . ($result["is_disposable"]   ? "true" : "false") . "\n";
echo "Score risque: {$result['risk_score']}/100\n";
if (!empty($result["did_you_mean"])) echo "Vouliez-vous dire : {$result['did_you_mean']} ?\n";

fmt.Printf("Valide      : %v\nDélivrable  : %v\nJetable     : %v\nScore risque: %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("Vouliez-vous dire :", typo+"?")
}

import org.json.*;

var r = new JSONObject(response.body());
System.out.printf("Valide      : %b%nDélivrable  : %b%nJetable     : %b%nScore risque: %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("Vouliez-vous dire : " + r.getString("did_you_mean") + "?");

using System.Text.Json;

var r = JsonDocument.Parse(body).RootElement;
Console.WriteLine($"Valide      : {r.GetProperty("is_valid").GetBoolean()}");
Console.WriteLine($"Délivrable  : {r.GetProperty("is_deliverable").GetBoolean()}");
Console.WriteLine($"Jetable     : {r.GetProperty("is_disposable").GetBoolean()}");
Console.WriteLine($"Score risque: {r.GetProperty("risk_score").GetInt32()}/100");
if (r.TryGetProperty("did_you_mean", out var typo) && typo.GetString() is { } t and not "")
    Console.WriteLine($"Vouliez-vous dire : {t} ?");

println!("Valide      : {}", result["is_valid"]);
println!("Délivrable  : {}", result["is_deliverable"]);
println!("Jetable     : {}", result["is_disposable"]);
println!("Score risque: {}/100", result["risk_score"]);
if let Some(typo) = result["did_you_mean"].as_str() {
    if !typo.is_empty() { println!("Vouliez-vous dire : {} ?", typo); }
}

Construire un flux d'inscription par niveau de risque

Utilisez risk_score pour router les utilisateurs : bloquer les adresses à haut risque, proposer des corrections de fautes de frappe, et appliquer une friction supplémentaire aux comptes rôle.

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": "Cette adresse email est invalide."}

    if v.get("is_disposable"):
        return {"ok": False, "error": "Les adresses email temporaires ne sont pas acceptées."}

    if v.get("did_you_mean"):
        return {"ok": False, "suggestion": f"Vouliez-vous dire {v['did_you_mean']} ?"}

    if v.get("risk_score", 0) >= 70:
        return {"ok": False, "error": "Score de risque élevé. Veuillez utiliser une autre adresse."}

    if v.get("is_role_account"):
        return {"ok": True, "flag": "role_account", "message": "Veuillez vérifier votre email."}

    return {"ok": True, "message": "Inscription réussie !"}

for test_email in ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]:
    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: "Adresse email invalide." };
  if (v.is_disposable)   return { ok: false, error: "Emails temporaires non acceptés." };
  if (v.did_you_mean)    return { ok: false, suggestion: `Vouliez-vous dire ${v.did_you_mean} ?` };
  if (v.risk_score >= 70) return { ok: false, error: "Score de risque élevé — utilisez une autre adresse." };
  if (v.is_role_account) return { ok: true,  flag: "role_account", message: "Veuillez vérifier votre email." };
  return { ok: true, message: "Inscription réussie !" };
}

for (const email of ["[email protected]", "[email protected]", "[email protected]", "[email protected]"]) {
  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" => "Email invalide."];
    if ($v["is_disposable"]   ?? false)  return ["ok" => false, "error" => "Emails temporaires non acceptés."];
    if (!empty($v["did_you_mean"]))      return ["ok" => false, "suggestion" => "Vouliez-vous dire {$v['did_you_mean']} ?"];
    if (($v["risk_score"]     ?? 0) >= 70) return ["ok" => false, "error" => "Score de risque élevé."];
    if ($v["is_role_account"] ?? false)  return ["ok" => true,  "flag" => "role_account"];
    return ["ok" => true, "message" => "Inscription réussie !"];
}

foreach (["[email protected]", "[email protected]", "[email protected]"] 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 "❌ Email invalide." }
    if v["is_disposable"].(bool)  { return "❌ Email temporaire non accepté." }
    if typo, ok := v["did_you_mean"].(string); ok && typo != "" {
        return "⚠️  Vouliez-vous dire " + typo + " ?"
    }
    if v["risk_score"].(float64) >= 70 { return "❌ Score de risque élevé." }
    return "✅ Inscription réussie !"
}

func main() {
    for _, email := range []string{"[email protected]", "[email protected]", "[email protected]"} {
        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 "❌ Email invalide.";
        if (v.getBoolean("is_disposable"))  return "❌ Email temporaire non accepté.";
        if (v.has("did_you_mean"))          return "⚠️  Vouliez-vous dire " + v.getString("did_you_mean") + " ?";
        if (v.getInt("risk_score") >= 70)   return "❌ Score de risque élevé.";
        return "✅ Inscription réussie !";
    }

    public static void main(String[] args) throws Exception {
        for (var email : new String[]{"[email protected]", "[email protected]", "[email protected]"}) {
            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 "❌ Email invalide.";
    if (v.GetProperty("is_disposable").GetBoolean())                  return "❌ Email temporaire non accepté.";
    if (v.TryGetProperty("did_you_mean", out var t) && t.GetString() is { Length: > 0 } typo)
                                                                      return $"⚠️  Vouliez-vous dire {typo} ?";
    if (v.GetProperty("risk_score").GetInt32() >= 70)                 return "❌ Score de risque élevé.";
    return "✅ Inscription réussie !";
}

foreach (var email in new[] { "[email protected]", "[email protected]", "[email protected]" })
    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 "❌ Email invalide."; }
    if  v["is_disposable"].as_bool().unwrap_or(false) { return "❌ Email temporaire non accepté."; }
    if  v["risk_score"].as_i64().unwrap_or(0) >= 70  { return "❌ Score de risque élevé."; }
    "✅ Inscription réussie !"
}

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

Les comptes rôle (admin@, info@, support@) sont souvent surveillés par plusieurs personnes — ou pas du tout. Marquez-les pour révision manuelle plutôt que de les bloquer, afin de ne pas perdre d'inscriptions B2B légitimes.