Vytvoření seznamu pro ověření e-mailů

Vytvoří nový seznam e-mailových adres pro hromadné ověření. Všechna ověření seznamů používají plný režim.

POST/email-verification-lists

Tělo požadavku

namestringRequired

Název ověřovacího seznamu.

emailsarrayRequired

Pole e-mailových adres k ověření. Maximálně 100 000 e-mailů na seznam.

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: 'Marketingový seznam Q1',
emails: [
  'uzivatel1@example.com',
  'uzivatel2@example.com',
  'uzivatel3@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' => 'Marketingový seznam Q1',
'emails' => [
  'uzivatel1@example.com',
  'uzivatel2@example.com',
  'uzivatel3@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 chyba #:" . $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': 'Marketingový seznam Q1',
    'emails': [
        'uzivatel1@example.com',
        'uzivatel2@example.com',
        'uzivatel3@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: 'Marketingový seznam Q1',
emails: [
'uzivatel1@example.com',
'uzivatel2@example.com',
'uzivatel3@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": "Marketingový seznam Q1",
    "emails": []string{
        "uzivatel1@example.com",
        "uzivatel2@example.com",
        "uzivatel3@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": "Marketingový seznam Q1",
        "emails": [
            "uzivatel1@example.com",
            "uzivatel2@example.com",
            "uzivatel3@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": "Marketingový seznam Q1",
            "emails": [
                "uzivatel1@example.com",
                "uzivatel2@example.com",
                "uzivatel3@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 = "Marketingový seznam Q1",
            emails = new[] {
                "uzivatel1@example.com",
                "uzivatel2@example.com",
                "uzivatel3@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": "Marketingový seznam Q1",
"emails": [
  "uzivatel1@example.com",
  "uzivatel2@example.com",
  "uzivatel3@example.com"
]
}'

{
"id": "evl_abc123xyz",
"name": "Marketingový seznam 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": "Chybný požadavek",
"message": "Pole emails je povinné a nesmí být prázdné"
}

{
"statusCode": 402,
"error": "Vyžadována platba",
"message": "Nedostatečný počet kreditů pro ověření e-mailů"
}

Pole odpovědi

Stav seznamu

Hodnota	Popis
pending	Seznam vytvořen, ověření nezahájeno
processing	Ověření probíhá
completed	Všechny e-maily byly ověřeny
failed	Ověření selhalo kvůli chybě

Objekt statistik

Pole	Typ	Popis
total_emails	integer	Celkový počet e-mailů v seznamu
processed_emails	integer	Počet e-mailů, které byly zpracovány
successful_verifications	integer	Počet úspěšně ověřených e-mailů
failed_verifications	integer	Počet neúspěšných ověření
pending_emails	integer	Počet e-mailů čekajících na ověření

Seznam seznamů pro ověření e-mailů

Získejte stránkovaný seznam všech seznamů pro ověření e-mailových adres ve vašem Emailit pracovním prostoru.

GET/email-verification-lists

Parametry dotazu

pageinteger

Číslo stránky. Výchozí: 1.

limitinteger

Počet položek na stránku (1-100). Výchozí: 10.

statusstring

Filtrovat podle stavu: 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 Error #:" . $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": "Marketingový seznam 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": "Neautorizováno"
}

Získat seznam pro ověření e-mailů

Načte podrobnosti konkrétního seznamu pro ověření e-mailů podle jeho ID.

GET/email-verification-lists/:id

Parametry cesty

idstringRequired

ID seznamu pro ověření e-mailů (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 "Chyba 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": "Marketingový seznam Q1",
"status": "dokončeno",
"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": "Nenalezeno",
"message": "Seznam pro ověření e-mailů nebyl nalezen"
}

Získání výsledků ověření e-mailového seznamu

Načtení výsledků ověření e-mailů v seznamu pro ověření.

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

Parametry cesty

idstringRequired

ID seznamu pro ověření e-mailů (evl_xxx).

Parametry dotazu

pageinteger

Číslo stránky. Výchozí: 1.

limitinteger

Počet položek na stránku (1-100). Výchozí: 50.

statusstring

Filtrování podle stavu: pending, processing, completed, failed.

resultstring

Filtrování podle výsledku: 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 chyba #:" . $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": "Seznam pro ověření e-mailů nebyl nalezen"
}

Pole odpovědi

Výsledek ověření

Hodnota	Popis
safe	E-mail je platný a doručitelný
invalid	E-mail je neplatný (syntaxe, doména nebo schránka)
disposable	E-mail používá jednorázovou/dočasnou doménu
disabled	Schránka existuje, ale je deaktivována
inbox_full	Schránka je plná a nemůže přijímat e-maily
unknown	Doručitelnost nelze určit

Úroveň rizika

Hodnota	Rozsah skóre	Popis
low	80-100	Bezpečné k odeslání
medium	50-79	Postupujte opatrně
high	0-49	Vysoké riziko vrácení

Export výsledků ověření e-mailových seznamů

Exportuje výsledky ověření jako XLSX soubor. Seznam pro ověření e-mailů musí být dokončen před exportem.

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

Parametry cesty

idstringRequired

ID seznamu pro ověření e-mailů (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'
}
});

// Odpověď je XLSX soubor
const blob = await response.blob();
// Uložte nebo zpracujte soubor

<?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 chyba #:" . $err;
} else {
// Uložte XLSX soubor
file_put_contents('vysledky_overeni.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'
}
)

# Uložte XLSX soubor
with open('vysledky_overeni.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)

# Uložte XLSX soubor
File.open('vysledky_overeni.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()

// Uložte XLSX soubor
out, _ := os.Create("vysledky_overeni.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?;

// Uložte XLSX soubor
let bytes = response.bytes().await?;
let mut file = File::create("vysledky_overeni.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 ExportVysledkuOvereni {
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());
    
    // Uložte XLSX soubor
    Files.write(Path.of("vysledky_overeni.xlsx"), response.body());
}
}

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

public class ExportVysledkuOvereni
{
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");
        
        // Uložte XLSX soubor
        var bytes = await response.Content.ReadAsByteArrayAsync();
        await File.WriteAllBytesAsync("vysledky_overeni.xlsx", bytes);
    }
}
}

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

Vrací stažení XLSX souboru s Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet

{
"statusCode": 400,
"error": "Bad Request",
"message": "Nelze exportovat nedokončený seznam. Seznam musí být nejprve dokončen."
}

{
"statusCode": 404,
"error": "Not Found",
"message": "Seznam pro ověření e-mailů nebyl nalezen"
}

Poznámky

Seznam musí mít stav completed (dokončeno) před tím, než může být exportován.
Exportovaný soubor obsahuje všechny výsledky ověření s podrobnými informacemi pro každý e-mail.
Velké seznamy mohou vyžadovat delší čas pro vygenerování exportního souboru.