Détecter les domaines jetables

Bloquez en temps réel les inscriptions avec des emails jetables en vérifiant si un domaine appartient à un fournisseur d'emails temporaires avec l'API Veille.

Vue d'ensemble

Les fournisseurs d'emails jetables permettent aux utilisateurs de créer des boîtes aux lettres temporaires supprimées après quelques minutes ou jours. Ce guide montre comment interroger l'endpoint de validation de domaine Veille et utiliser le résultat pour bloquer ou signaler des inscriptions au moment de l'enregistrement.

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

Vérifier un domaine

Appelez GET /v1/domain avec le paramètre domain. La réponse indique si le domaine est jetable, gratuit ou personnalisé.

import requests

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

const API_KEY = "YOUR_API_KEY";

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

<?php
$apiKey = "YOUR_API_KEY";
$params = http_build_query(["domain" => "mailinator.com"]);

$ch = curl_init("https://api.veille.io/v1/domain?{$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"
)

func main() {
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/domain?domain=mailinator.com", 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.http.*;

var client  = HttpClient.newHttpClient();
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.veille.io/v1/domain?domain=mailinator.com"))
    .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 body = await client.GetStringAsync("https://api.veille.io/v1/domain?domain=mailinator.com");
Console.WriteLine(body);

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

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

Lire les champs de la réponse

La réponse inclut is_disposable, is_free, is_custom, domain et provider (quand identifié).

domain        = result.get("domain")
is_disposable = result.get("is_disposable")
is_free       = result.get("is_free")
provider      = result.get("provider", "inconnu")

if is_disposable:
    print(f"❌ {domain} est un fournisseur d'email JETABLE ({provider}). Bloquer cette inscription.")
elif is_free:
    print(f"⚠️  {domain} est un fournisseur d'email gratuit. Envisagez une vérification supplémentaire.")
else:
    print(f"✅ {domain} ressemble à un domaine professionnel. Autoriser.")

const { domain, is_disposable, is_free, provider } = result;

if (is_disposable) {
  console.log(`❌ ${domain} est JETABLE (${provider ?? "inconnu"}). Bloquer cette inscription.`);
} else if (is_free) {
  console.log(`⚠️  ${domain} est un fournisseur gratuit. Envisagez une vérification supplémentaire.`);
} else {
  console.log(`✅ ${domain} ressemble à un domaine professionnel. Autoriser.`);
}

$domain      = $result["domain"] ?? "";
$isDisposable = $result["is_disposable"] ?? false;
$isFree       = $result["is_free"] ?? false;
$provider     = $result["provider"] ?? "inconnu";

if ($isDisposable) {
    echo "❌ {$domain} est JETABLE ({$provider}). Bloquer cette inscription.\n";
} elseif ($isFree) {
    echo "⚠️  {$domain} est gratuit. Vérification supplémentaire conseillée.\n";
} else {
    echo "✅ {$domain} ressemble à un domaine professionnel. Autoriser.\n";
}

domain        := result["domain"].(string)
isDisposable  := result["is_disposable"].(bool)
isFree        := result["is_free"].(bool)
provider, _   := result["provider"].(string)

switch {
case isDisposable:
    fmt.Printf("❌ %s est JETABLE (%s). Bloquer cette inscription.\n", domain, provider)
case isFree:
    fmt.Printf("⚠️  %s est un fournisseur gratuit.\n", domain)
default:
    fmt.Printf("✅ %s est un domaine professionnel. Autoriser.\n", domain)
}

import org.json.*;

var r            = new JSONObject(response.body());
var domain       = r.getString("domain");
var isDisposable = r.getBoolean("is_disposable");
var isFree       = r.getBoolean("is_free");
var provider     = r.optString("provider", "inconnu");

if (isDisposable)      System.out.printf("❌ %s est JETABLE (%s). Bloquer.%n", domain, provider);
else if (isFree)       System.out.printf("⚠️  %s est gratuit. Vérification supplémentaire.%n", domain);
else                   System.out.printf("✅ %s est un domaine professionnel. Autoriser.%n", domain);

using System.Text.Json;

var r            = JsonDocument.Parse(body).RootElement;
var domain       = r.GetProperty("domain").GetString();
var isDisposable = r.GetProperty("is_disposable").GetBoolean();
var isFree       = r.GetProperty("is_free").GetBoolean();
var provider     = r.TryGetProperty("provider", out var p) ? p.GetString() : "inconnu";

if (isDisposable)
    Console.WriteLine($"❌ {domain} est JETABLE ({provider}). Bloquer.");
else if (isFree)
    Console.WriteLine($"⚠️  {domain} est gratuit. Vérification supplémentaire.");
else
    Console.WriteLine($"✅ {domain} est un domaine professionnel. Autoriser.");

let domain       = result["domain"].as_str().unwrap_or("");
let is_disposable = result["is_disposable"].as_bool().unwrap_or(false);
let is_free       = result["is_free"].as_bool().unwrap_or(false);
let provider      = result["provider"].as_str().unwrap_or("inconnu");

if is_disposable {
    println!("❌ {} est JETABLE ({}). Bloquer.", domain, provider);
} else if is_free {
    println!("⚠️  {} est gratuit. Vérification supplémentaire.", domain);
} else {
    println!("✅ {} est un domaine professionnel. Autoriser.", domain);
}

Intégrer dans un gestionnaire d'inscription

Ajoutez la vérification du domaine à votre endpoint d'enregistrement et retournez une erreur de validation avant que l'enregistrement utilisateur ne soit créé.

import requests

API_KEY = "YOUR_API_KEY"

def is_disposable_email(email: str) -> bool:
    domain = email.split("@")[-1].lower()
    r = requests.get("https://api.veille.io/v1/domain",
        headers={"x-api-key": API_KEY}, params={"domain": domain})
    return r.json().get("is_disposable", False)

def register_user(email: str, password: str) -> dict:
    if is_disposable_email(email):
        return {"success": False, "error": "Les adresses email jetables ne sont pas autorisées."}
    # ... créer l'enregistrement utilisateur dans votre base de données
    return {"success": True, "message": f"Bienvenue, {email} !"}

print(register_user("[email protected]", "secret"))
print(register_user("[email protected]",    "secret"))

const API_KEY = "YOUR_API_KEY";

async function isDisposableEmail(email: string): Promise<boolean> {
  const domain = email.split("@").at(-1)!.toLowerCase();
  const params = new URLSearchParams({ domain });
  const res    = await fetch(`https://api.veille.io/v1/domain?${params}`, {
    headers: { "x-api-key": API_KEY },
  });
  return (await res.json()).is_disposable ?? false;
}

async function registerUser(email: string, password: string) {
  if (await isDisposableEmail(email)) {
    return { success: false, error: "Les adresses email jetables ne sont pas autorisées." };
  }
  // ... créer l'enregistrement utilisateur
  return { success: true, message: `Bienvenue, ${email} !` };
}

console.log(await registerUser("[email protected]", "secret"));
console.log(await registerUser("[email protected]",    "secret"));

<?php
function isDisposableEmail(string $apiKey, string $email): bool {
    $domain = strtolower(explode("@", $email)[1]);
    $params = http_build_query(["domain" => $domain]);
    $ch = curl_init("https://api.veille.io/v1/domain?{$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["is_disposable"] ?? false;
}

function registerUser(string $apiKey, string $email, string $password): array {
    if (isDisposableEmail($apiKey, $email)) {
        return ["success" => false, "error" => "Les adresses email jetables ne sont pas autorisées."];
    }
    // ... créer l'enregistrement utilisateur
    return ["success" => true, "message" => "Bienvenue, {$email} !"];
}

print_r(registerUser("YOUR_API_KEY", "[email protected]", "secret"));
print_r(registerUser("YOUR_API_KEY", "[email protected]",    "secret"));

package main

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

func isDisposable(apiKey, email string) bool {
    domain := strings.ToLower(strings.SplitN(email, "@", 2)[1])
    req, _ := http.NewRequest("GET", "https://api.veille.io/v1/domain?domain="+domain, nil)
    req.Header.Set("x-api-key", apiKey)
    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    var result map[string]any
    json.Unmarshal(body, &result)
    v, _ := result["is_disposable"].(bool)
    return v
}

func registerUser(apiKey, email, password string) string {
    if isDisposable(apiKey, email) {
        return "❌ Email jetable non autorisé."
    }
    return "✅ Bienvenue, " + email + " !"
}

func main() {
    apiKey := "YOUR_API_KEY"
    fmt.Println(registerUser(apiKey, "[email protected]", "secret"))
    fmt.Println(registerUser(apiKey, "[email protected]",    "secret"))
}

import java.net.URI;
import java.net.http.*;
import org.json.*;

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

    static boolean isDisposable(String email) throws Exception {
        var domain  = email.substring(email.indexOf('@') + 1).toLowerCase();
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.veille.io/v1/domain?domain=" + domain))
            .header("x-api-key", API_KEY).GET().build();
        var resp    = client.send(request, HttpResponse.BodyHandlers.ofString());
        return new JSONObject(resp.body()).optBoolean("is_disposable", false);
    }

    static String registerUser(String email, String password) throws Exception {
        if (isDisposable(email)) return "❌ Email jetable non autorisé.";
        return "✅ Bienvenue, " + email + " !";
    }

    public static void main(String[] args) throws Exception {
        System.out.println(registerUser("[email protected]", "secret"));
        System.out.println(registerUser("[email protected]",    "secret"));
    }
}

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<bool> IsDisposable(string email)
{
    var domain = email.Split('@').Last().ToLower();
    var body   = await client.GetStringAsync($"https://api.veille.io/v1/domain?domain={domain}");
    return JsonDocument.Parse(body).RootElement.GetProperty("is_disposable").GetBoolean();
}

async Task<string> RegisterUser(string email, string password) =>
    await IsDisposable(email)
        ? "❌ Email jetable non autorisé."
        : $"✅ Bienvenue, {email} !";

Console.WriteLine(await RegisterUser("[email protected]", "secret"));
Console.WriteLine(await RegisterUser("[email protected]",    "secret"));

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

async fn is_disposable(client: &Client, api_key: &str, email: &str) -> bool {
    let domain = email.split('@').last().unwrap_or("").to_lowercase();
    let result = client.get("https://api.veille.io/v1/domain")
        .header("x-api-key", api_key)
        .query(&[("domain", domain.as_str())])
        .send().await.unwrap().json::<Value>().await.unwrap();
    result["is_disposable"].as_bool().unwrap_or(false)
}

#[tokio::main]
async fn main() -> Result<(), reqwest::Error> {
    let client  = Client::new();
    let api_key = "YOUR_API_KEY";

    for email in ["[email protected]", "[email protected]"] {
        if is_disposable(&client, api_key, email).await {
            println!("❌ {} — jetable. Bloquer.", email);
        } else {
            println!("✅ {} — valide. Autoriser.", email);
        }
    }
    Ok(())
}

Mettez en cache les résultats des domaines vérifiés fréquemment (p. ex. dans Redis avec un TTL de 24h) pour éviter des appels API redondants. La liste des fournisseurs jetables évolue rarement dans une même journée.