E-Mail-Verifizierungsliste erstellen

Erstellen Sie eine neue E-Mail-Verifizierungsliste für die Massenverifizierung. Alle Listenverifizierungen verwenden den vollständigen Modus.

POST/email-verification-lists

Request Body

namestringRequired

Name der Verifizierungsliste.

emailsarrayRequired

Array von E-Mail-Adressen zur Verifizierung. Maximal 100.000 E-Mails pro 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: 'Marketing Liste Q1',
emails: [
  'user1@example.com',
  'user2@example.com',
  'user3@example.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' => 'Marketing Liste Q1',
'emails' => [
  'user1@example.com',
  'user2@example.com',
  'user3@example.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 "cURL Fehler #:" . $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': 'Marketing Liste Q1',
    'emails': [
        'user1@example.com',
        'user2@example.com',
        'user3@example.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: 'Marketing Liste Q1',
emails: [
'user1@example.com',
'user2@example.com',
'user3@example.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": "Marketing Liste Q1",
    "emails": []string{
        "user1@example.com",
        "user2@example.com",
        "user3@example.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": "Marketing Liste Q1",
        "emails": [
            "user1@example.com",
            "user2@example.com",
            "user3@example.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": "Marketing Liste Q1",
            "emails": [
                "user1@example.com",
                "user2@example.com",
                "user3@example.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 = "Marketing Liste Q1",
            emails = new[] {
                "user1@example.com",
                "user2@example.com",
                "user3@example.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": "Marketing Liste Q1",
"emails": [
  "user1@example.com",
  "user2@example.com",
  "user3@example.com"
]
}'

{
"id": "evl_abc123xyz",
"name": "Marketing Liste Q1",
"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": "Bad Request",
"message": "E-Mail-Array ist erforderlich und darf nicht leer sein"
}

{
"statusCode": 402,
"error": "Payment Required",
"message": "Unzureichende Credits für E-Mail-Verifizierung"
}

Antwortfelder

Listenstatus

Wert	Beschreibung
pending	Liste erstellt, Verifizierung noch nicht gestartet
processing	Verifizierung läuft
completed	Alle E-Mails wurden verifiziert
failed	Verifizierung aufgrund eines Fehlers fehlgeschlagen

Stats-Objekt

Feld	Typ	Beschreibung
total_emails	integer	Gesamtanzahl der E-Mails in der Liste
processed_emails	integer	Anzahl der bereits verarbeiteten E-Mails
successful_verifications	integer	Anzahl der erfolgreich verifizierten E-Mails
failed_verifications	integer	Anzahl der fehlgeschlagenen Verifizierungen
pending_emails	integer	Anzahl der noch ausstehenden E-Mails zur Verifizierung

E-Mail-Verifizierungslisten abrufen

Rufen Sie eine paginierte Liste aller E-Mail-Verifizierungslisten in Ihrem Emailit-Arbeitsbereich ab.

GET/email-verification-lists

Abfrageparameter

pageinteger

Seitennummer. Standard: 1.

limitinteger

Einträge pro Seite (1-100). Standard: 10.

statusstring

Nach Status filtern: 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 "cURL-Fehler #:" . $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": "Marketing-Liste Q1",
  "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": "Nicht autorisiert"
}

E-Mail-Verifizierungsliste abrufen

Ruft die Details einer bestimmten E-Mail-Verifizierungsliste über ihre ID ab.

GET/email-verification-lists/:id

Pfad-Parameter

idstringRequired

ID der E-Mail-Verifizierungsliste (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 "cURL-Fehler #:" . $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": "Marketing-Liste Q1",
"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": "Nicht gefunden",
"message": "E-Mail-Verifizierungsliste nicht gefunden"
}

E-Mail-Verifizierungslisten-Ergebnisse abrufen

Rufen Sie die Verifizierungsergebnisse für E-Mails in einer Verifizierungsliste ab.

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

Pfad-Parameter

idstringRequired

E-Mail-Verifizierungslisten-ID (evl_xxx).

Query-Parameter

pageinteger

Seitennummer. Standard: 1.

limitinteger

Einträge pro Seite (1-100). Standard: 50.

statusstring

Nach Status filtern: pending, processing, completed, failed.

resultstring

Nach Ergebnis filtern: 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 "cURL-Fehler #:" . $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": "E-Mail-Verifizierungsliste nicht gefunden"
}

Antwort-Felder

Verifizierungsergebnis

Wert	Beschreibung
safe	E-Mail ist gültig und zustellbar
invalid	E-Mail ist ungültig (Syntax, Domain oder Postfach)
disposable	E-Mail verwendet eine Wegwerf-/temporäre Domain
disabled	Postfach existiert, ist aber deaktiviert
inbox_full	Postfach ist voll und kann keine E-Mails empfangen
unknown	Zustellbarkeit konnte nicht ermittelt werden

Risikostufe

Wert	Punktebereich	Beschreibung
low	80-100	Sicher zu versenden
medium	50-79	Mit Vorsicht verwenden
high	0-49	Hohes Bounce-Risiko

E-Mail-Verifizierungsliste exportieren

Exportieren Sie Verifizierungsergebnisse als XLSX-Datei. Die Verifizierungsliste muss vor dem Export vollständig abgeschlossen sein.

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

Pfad-Parameter

idstringRequired

ID der E-Mail-Verifizierungsliste (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'
}
});

// Antwort ist eine XLSX-Datei
const blob = await response.blob();
// Datei speichern oder verarbeiten

<?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 "cURL-Fehler #:" . $err;
} else {
// XLSX-Datei speichern
file_put_contents('verifizierungsergebnisse.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'
}
)

# XLSX-Datei speichern
with open('verifizierungsergebnisse.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)

# XLSX-Datei speichern
File.open('verifizierungsergebnisse.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()

// XLSX-Datei speichern
out, _ := os.Create("verifizierungsergebnisse.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?;

// XLSX-Datei speichern
let bytes = response.bytes().await?;
let mut file = File::create("verifizierungsergebnisse.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 ExportVerificationResults {
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());
    
    // XLSX-Datei speichern
    Files.write(Path.of("verifizierungsergebnisse.xlsx"), response.body());
}
}

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

public class ExportVerificationResults
{
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");
        
        // XLSX-Datei speichern
        var bytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("verifizierungsergebnisse.xlsx", bytes);
    }
}
}

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

Gibt eine XLSX-Datei zum Download zurück mit Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet

{
"statusCode": 400,
"error": "Bad Request",
"message": "Unvollständige Liste kann nicht exportiert werden. Liste muss zuerst abgeschlossen werden."
}

{
"statusCode": 404,
"error": "Not Found",
"message": "E-Mail-Verifizierungsliste nicht gefunden"
}

Hinweise

Die Liste muss den Status completed (abgeschlossen) haben, bevor sie exportiert werden kann.
Die exportierte Datei enthält alle Verifizierungsergebnisse mit detaillierten Informationen zu jeder E-Mail-Adresse.
Bei umfangreichen Listen kann die Generierung der Export-Datei länger dauern.

E-Mail-Verifizierungsliste erstellen

Request Body

Antwortfelder

Listenstatus

Stats-Objekt

E-Mail-Verifizierungslisten abrufen

Abfrageparameter

E-Mail-Verifizierungsliste abrufen

Pfad-Parameter

E-Mail-Verifizierungslisten-Ergebnisse abrufen

Pfad-Parameter

Query-Parameter

Antwort-Felder

Verifizierungsergebnis

Risikostufe

E-Mail-Verifizierungsliste exportieren

Pfad-Parameter

Hinweise

Lokalisiert durch KI