Créer une liste de vérification d’emails

Créez une nouvelle liste de vérification d’emails pour la vérification en lot. Toutes les vérifications de listes utilisent le mode complet.

POST/email-verification-lists

Corps de la requête

namestringRequired

Nom de la liste de vérification.

emailsarrayRequired

Tableau d’adresses email à vérifier. Maximum 100 000 emails par liste.

const response = await fetch('https://api.emailit.com/v2/email-verification-lists', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
name: 'Liste Marketing T1',
emails: [
  'utilisateur1@exemple.com',
  'utilisateur2@exemple.com',
  'utilisateur3@exemple.com'
]
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/email-verification-lists',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
CURLOPT_POSTFIELDS => json_encode([
'name' => 'Liste Marketing T1',
'emails' => [
  'utilisateur1@exemple.com',
  'utilisateur2@exemple.com',
  'utilisateur3@exemple.com'
]
]),
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.post(
'https://api.emailit.com/v2/email-verification-lists',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'name': 'Liste Marketing T1',
    'emails': [
        'utilisateur1@exemple.com',
        'utilisateur2@exemple.com',
        'utilisateur3@exemple.com'
    ]
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/email-verification-lists')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Post.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
name: 'Liste Marketing T1',
emails: [
'utilisateur1@exemple.com',
'utilisateur2@exemple.com',
'utilisateur3@exemple.com'
]
}.to_json

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/email-verification-lists"

data := map[string]interface{}{
    "name": "Liste Marketing T1",
    "emails": []string{
        "utilisateur1@exemple.com",
        "utilisateur2@exemple.com",
        "utilisateur3@exemple.com",
    },
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::{json, Value};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .post("https://api.emailit.com/v2/email-verification-lists")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "name": "Liste Marketing T1",
        "emails": [
            "utilisateur1@exemple.com",
            "utilisateur2@exemple.com",
            "utilisateur3@exemple.com"
        ]
    }))
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.net.http.HttpRequest.BodyPublishers;

public class CreateVerificationList {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = """
        {
            "name": "Liste Marketing T1",
            "emails": [
                "utilisateur1@exemple.com",
                "utilisateur2@exemple.com",
                "utilisateur3@exemple.com"
            ]
        }
        """;
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/email-verification-lists"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .POST(BodyPublishers.ofString(jsonBody))
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

public class CreateVerificationList
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new {
            name = "Liste Marketing T1",
            emails = new[] {
                "utilisateur1@exemple.com",
                "utilisateur2@exemple.com",
                "utilisateur3@exemple.com"
            }
        };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/email-verification-lists", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/email-verification-lists \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"name": "Liste Marketing T1",
"emails": [
  "utilisateur1@exemple.com",
  "utilisateur2@exemple.com",
  "utilisateur3@exemple.com"
]
}'

{
"id": "evl_abc123xyz",
"name": "Liste Marketing T1",
"status": "pending",
"stats": {
"total_emails": 3,
"processed_emails": 0,
"successful_verifications": 0,
"failed_verifications": 0,
"pending_emails": 3
},
"created_at": "2026-02-02T10:30:00.000Z",
"updated_at": "2026-02-02T10:30:00.000Z"
}

{
"statusCode": 400,
"error": "Requête incorrecte",
"message": "Le tableau d'emails est requis et ne peut pas être vide"
}

{
"statusCode": 402,
"error": "Paiement requis",
"message": "Crédits insuffisants pour la vérification d'emails"
}

Champs de réponse

Statut de la liste

Valeur	Description
pending	Liste créée, vérification non démarrée
processing	Vérification en cours
completed	Tous les emails ont été vérifiés
failed	La vérification a échoué en raison d’une erreur

Objet stats

Champ	Type	Description
total_emails	integer	Nombre total d’emails dans la liste
processed_emails	integer	Nombre d’emails qui ont été traités
successful_verifications	integer	Nombre d’emails vérifiés avec succès
failed_verifications	integer	Nombre de vérifications échouées
pending_emails	integer	Nombre d’emails en attente de vérification

Lister les listes de vérification d’emails

Récupérez une liste paginée de toutes les listes de vérification d’emails dans votre espace de travail Emailit.

GET/email-verification-lists

Paramètres de requête

pageinteger

Numéro de page. Par défaut : 1.

limitinteger

Éléments par page (1-100). Par défaut : 10.

statusstring

Filtrer par statut : pending, processing, completed, failed.

const response = await fetch('https://api.emailit.com/v2/email-verification-lists?page=1&limit=10', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/email-verification-lists?page=1&limit=10',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/email-verification-lists',
params={
    'page': 1,
    'limit': 10
},
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/email-verification-lists?page=1&limit=10')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

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

func main() {
baseURL := "https://api.emailit.com/v2/email-verification-lists"
params := url.Values{}
params.Add("page", "1")
params.Add("limit", "10")

fullURL := baseURL + "?" + params.Encode()

req, _ := http.NewRequest("GET", fullURL, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/email-verification-lists")
    .query(&[("page", "1"), ("limit", "10")])
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class ListVerificationLists {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/email-verification-lists?page=1&limit=10"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class ListVerificationLists
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/email-verification-lists?page=1&limit=10");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET "https://api.emailit.com/v2/email-verification-lists?page=1&limit=10" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"data": [
{
  "id": "evl_abc123xyz",
  "name": "Liste Marketing T1",
  "status": "completed",
  "stats": {
    "total_emails": 1000,
    "processed_emails": 1000,
    "successful_verifications": 950,
    "failed_verifications": 50,
    "pending_emails": 0
  },
  "created_at": "2026-02-02T10:30:00.000Z",
  "updated_at": "2026-02-02T11:45:00.000Z"
}
],
"next_page_url": "/v2/email-verification-lists?page=2&limit=10",
"previous_page_url": null
}

{
"message": "Non autorisé"
}

Récupérer une liste de vérification d’emails

Récupère les détails d’une liste de vérification d’emails spécifique par son identifiant.

GET/email-verification-lists/:id

Paramètres de chemin

idstringRequired

Identifiant de la liste de vérification d’emails (evl_xxx).

const response = await fetch('https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

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

func main() {
url := "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetVerificationList {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetVerificationList
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"id": "evl_abc123xyz",
"name": "Liste Marketing T1",
"status": "completed",
"stats": {
"total_emails": 1000,
"processed_emails": 1000,
"successful_verifications": 950,
"failed_verifications": 50,
"pending_emails": 0
},
"created_at": "2026-02-02T10:30:00.000Z",
"updated_at": "2026-02-02T11:45:00.000Z"
}

{
"statusCode": 404,
"error": "Non trouvé",
"message": "Liste de vérification d'emails introuvable"
}

Récupérer les résultats de vérification d’une liste d’emails

Récupère les résultats de vérification pour les emails d’une liste de vérification.

GET/email-verification-lists/:id/results

Paramètres de chemin

idstringRequired

Identifiant de la liste de vérification d’emails (evl_xxx).

Paramètres de requête

pageinteger

Numéro de page. Par défaut : 1.

limitinteger

Éléments par page (1-100). Par défaut : 50.

statusstring

Filtrer par statut : pending, processing, completed, failed.

resultstring

Filtrer par résultat : safe, invalid, disposable, disabled, inbox_full, unknown.

const response = await fetch('https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results?page=1&limit=50', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
}
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results?page=1&limit=50',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type: application/json'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results',
params={
    'page': 1,
    'limit': 50
},
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results?page=1&limit=50')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'

response = http.request(request)
result = JSON.parse(response.body)
puts result

package main

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

func main() {
baseURL := "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results"
params := url.Values{}
params.Add("page", "1")
params.Add("limit", "50")

fullURL := baseURL + "?" + params.Encode()

req, _ := http.NewRequest("GET", fullURL, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
req.Header.Set("Content-Type", "application/json")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

var result map[string]interface{}
json.NewDecoder(resp.Body).Decode(&result)
fmt.Println(result)
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results")
    .query(&[("page", "1"), ("limit", "50")])
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

let result: Value = response.json().await?;
println!("{:?}", result);

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class GetVerificationResults {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results?page=1&limit=50"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .GET()
        .build();
    
    HttpResponse<String> response = client.send(request, 
        HttpResponse.BodyHandlers.ofString());
    
    System.out.println(response.body());
}
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class GetVerificationResults
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results?page=1&limit=50");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/results?page=1&limit=50" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"data": [
{
  "id": "ev_xyz789abc",
  "email": "user1@example.com",
  "status": "completed",
  "result": "safe",
  "score": 100,
  "risk": "low",
  "mx_records": [
    {
      "priority": 10,
      "exchange": "mail.example.com"
    }
  ],
  "error_message": null,
  "created_at": "2026-02-02T10:30:05.000Z",
  "updated_at": "2026-02-02T10:30:10.000Z"
},
{
  "id": "ev_def456ghi",
  "email": "invalid@fake-domain.xyz",
  "status": "completed",
  "result": "invalid",
  "score": 0,
  "risk": "high",
  "mx_records": null,
  "error_message": null,
  "created_at": "2026-02-02T10:30:05.000Z",
  "updated_at": "2026-02-02T10:30:12.000Z"
}
],
"next_page_url": "/v2/email-verification-lists/evl_abc123xyz/results?page=2&limit=50",
"previous_page_url": null
}

{
"statusCode": 404,
"error": "Not Found",
"message": "Liste de vérification d'emails introuvable"
}

Champs de réponse

Résultat de vérification

Valeur	Description
safe	L’email est valide et peut recevoir des messages
invalid	L’email est invalide (syntaxe, domaine ou boîte mail)
disposable	L’email utilise un domaine jetable/temporaire
disabled	La boîte mail existe mais est désactivée
inbox_full	La boîte mail est pleine et ne peut pas recevoir d’emails
unknown	Impossible de déterminer la délivrabilité

Niveau de risque

Valeur	Plage de score	Description
low	80-100	Sûr pour l’envoi
medium	50-79	Utiliser avec prudence
high	0-49	Risque élevé de rebond

Exporter les résultats de la liste de vérification d’emails

Exportez les résultats de vérification sous forme de fichier XLSX. La liste de vérification doit être terminée avant l’exportation.

GET/email-verification-lists/:id/export

Paramètres de chemin

idstringRequired

Identifiant de la liste de vérification d’emails (evl_xxx).

const response = await fetch('https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export', {
method: 'GET',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
}
});

// La réponse est un fichier XLSX
const blob = await response.blob();
// Enregistrer ou traiter le fichier

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'GET',
CURLOPT_HTTPHEADER => [
'Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE'
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "Erreur cURL #:" . $err;
} else {
// Enregistrer le fichier XLSX
file_put_contents('resultats_verification.xlsx', $response);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
}
)

# Enregistrer le fichier XLSX
with open('resultats_verification.xlsx', 'wb') as f:
f.write(response.content)

require 'net/http'

uri = URI('https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'

response = http.request(request)

# Enregistrer le fichier XLSX
File.open('resultats_verification.xlsx', 'wb') do |file|
file.write(response.body)
end

package main

import (
"io"
"net/http"
"os"
)

func main() {
url := "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export"

req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")

client := &http.Client{}
resp, _ := client.Do(req)
defer resp.Body.Close()

// Enregistrer le fichier XLSX
out, _ := os.Create("resultats_verification.xlsx")
defer out.Close()
io.Copy(out, resp.Body)
}

use reqwest;
use std::fs::File;
use std::io::copy;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let client = reqwest::Client::new();

let response = client
    .get("https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .send()
    .await?;

// Enregistrer le fichier XLSX
let bytes = response.bytes().await?;
let mut file = File::create("resultats_verification.xlsx")?;
copy(&mut bytes.as_ref(), &mut file)?;

Ok(())
}

import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Path;

public class ExportResultatsVerification {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .GET()
        .build();
    
    HttpResponse<byte[]> response = client.send(request, 
        HttpResponse.BodyHandlers.ofByteArray());
    
    // Enregistrer le fichier XLSX
    Files.write(Path.of("resultats_verification.xlsx"), response.body());
}
}

using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

public class ExportResultatsVerification
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.GetAsync(
            "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export");
        
        // Enregistrer le fichier XLSX
        var bytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("resultats_verification.xlsx", bytes);
    }
}
}

curl -X GET "https://api.emailit.com/v2/email-verification-lists/evl_abc123xyz/export" \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-o resultats_verification.xlsx

Retourne un téléchargement de fichier XLSX avec Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet

{
"statusCode": 400,
"error": "Requête incorrecte",
"message": "Impossible d'exporter une liste incomplète. La liste doit d'abord être terminée."
}

{
"statusCode": 404,
"error": "Non trouvé",
"message": "Liste de vérification d'emails introuvable"
}

Remarques

La liste doit avoir le statut completed (terminée) avant de pouvoir être exportée.
Le fichier exporté contient tous les résultats de vérification avec des informations détaillées pour chaque email.
Les listes volumineuses peuvent nécessiter plus de temps pour générer le fichier d’export.

Créer une liste de vérification d’emails

Corps de la requête

Champs de réponse

Statut de la liste

Objet stats

Lister les listes de vérification d’emails

Paramètres de requête

Récupérer une liste de vérification d’emails

Paramètres de chemin

Récupérer les résultats de vérification d’une liste d’emails

Paramètres de chemin

Paramètres de requête

Champs de réponse

Résultat de vérification

Niveau de risque

Exporter les résultats de la liste de vérification d’emails

Paramètres de chemin

Remarques

Localisé par IA