Vytvoření domény

Vytvořte doménu prostřednictvím Emailit API.

POST/domains

Tělo požadavku

namestringRequired

Název domény ve formátu mail.vasedomena.cz.

track_loadsboolean

Zda sledovat načítání e-mailů pro tuto doménu (výchozí: false).

track_clicksboolean

Zda sledovat kliknutí v e-mailech pro tuto doménu (výchozí: false).

const response = await fetch('https://api.emailit.com/v2/domains', {
method: 'POST',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
name: 'mail.vasedomena.cz',
track_loads: false,
track_clicks: false
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains',
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' => 'mail.vasedomena.cz',
'track_loads' => false,
'track_clicks' => false
]),
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/domains',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'name': 'mail.vasedomena.cz',
    'track_loads': False,
    'track_clicks': False
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains')
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: 'mail.vasedomena.cz',
track_loads: false,
track_clicks: false
}.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/domains"

data := map[string]interface{}{
    "name": "mail.vasedomena.cz",
    "track_loads": false,
    "track_clicks": false,
}

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/domains")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "name": "mail.vasedomena.cz",
        "track_loads": false,
        "track_clicks": false
    }))
    .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 CreateDomain {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"name\":\"mail.vasedomena.cz\",\"track_loads\":false,\"track_clicks\":false}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains"))
        .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 CreateDomain
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { name = "mail.vasedomena.cz", track_loads = false, track_clicks = false };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var response = await client.PostAsync(
            "https://api.emailit.com/v2/domains", content);
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X POST https://api.emailit.com/v2/domains \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"name": "mail.vasedomena.cz",
"track_loads": false,
"track_clicks": false
}'

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.vasedomena.cz",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": null,
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": null,
"spf_status": null,
"spf_error": null,
"dkim_status": null,
"dkim_error": null,
"mx_status": null,
"mx_error": null,
"return_path_status": null,
"return_path_error": null,
"dmarc_status": null,
"dmarc_error": null,
"tracking_status": null,
"tracking_error": null,
"inbound_status": null,
"inbound_error": null,
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T00:00:00Z"
}

{
"error": {
"code": 400,
"message": "Neplatný požadavek"
}
}

{
"error": {
"code": 409,
"message": "Doména již existuje"
},
"existing": {
"object": "domain",
"id": 1234567890,
"name": "mail.vasedomena.cz"
}
}

Získat doménu

Načte informace o konkrétní doméně ve vašem Emailit účtu.

GET/domains/{id}

Parametry cesty

idstringRequired

ID domény, kterou chcete načíst.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890', {
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/domains/sd_1234567890',
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/domains/sd_1234567890',
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/domains/sd_1234567890')
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/domains/sd_1234567890"

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/domains/sd_1234567890")
    .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 GetDomain {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains/sd_1234567890"))
        .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 GetDomain
{
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/domains/sd_1234567890");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X GET https://api.emailit.com/v2/domains/sd_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.vasedomena.cz",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": "2021-01-01T12:00:00Z",
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "ok",
"spf_error": null,
"dkim_status": "ok",
"dkim_error": null,
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "ok",
"dmarc_error": null,
"tracking_status": "ok",
"tracking_error": null,
"inbound_status": "ok",
"inbound_error": null,
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T00:00:00Z"
}

{
"error": {
"code": 401,
"message": "Neautorizováno"
}
}

{
"error": {
"code": 404,
"message": "Doména nebyla nalezena"
}
}

Ověřit doménu

Ověří, že požadované DNS záznamy byly správně nakonfigurovány pro doménu. Tento endpoint zkontroluje všechny DNS záznamy (MX, SPF, DKIM a DMARC) a aktualizuje stav ověření domény.

POST/domains/{id}/verify

Parametry cesty

idstringRequired

ID domény, kterou chcete ověřit.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890/verify', {
method: 'POST',
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/domains/sd_1234567890/verify',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'POST',
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/domains/sd_1234567890/verify',
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/domains/sd_1234567890/verify')
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'

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

curl -X POST https://api.emailit.com/v2/domains/sd_1234567890/verify \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.vasedomena.cz",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": "2021-01-01T12:00:00Z",
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "ok",
"spf_error": null,
"dkim_status": "ok",
"dkim_error": null,
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "ok",
"dmarc_error": null,
"tracking_status": "ok",
"tracking_error": null,
"inbound_status": "ok",
"inbound_error": null,
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC+hb3/Ew7dLpCYVAThs29xMy2aWDPhhdMarieUn/N6x8DOaMar3BQV3ilzUb5F+axVxSYisd6mw9FGuZ48uD2KcOXBWjl5E1R5pYuB13KuVwXUwyzsEeYsGE6kYIpu7Rxn3wQvcGhCrx3RK30Hyw0yNpAcpUtmo+wbIYkJutOquwIDAQAB;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.vasedomena.cz",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": null,
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "failed",
"spf_error": "SPF záznam nebyl nalezen",
"dkim_status": "failed",
"dkim_error": "DKIM záznam nebyl nalezen",
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "pending",
"dmarc_error": null,
"tracking_status": "missing",
"tracking_error": "Nebyly nalezeny žádné CNAME záznamy na tr.vasedomena.cz",
"inbound_status": "missing",
"inbound_error": "Nebyly nalezeny žádné MX záznamy na inbound.vasedomena.cz",
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "failed",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": "SPF záznam nebyl nalezen"
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.vasedomena.cz",
  "ttl": "auto",
  "status": "failed",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA....",
  "priority": null,
  "error": "DKIM záznam nebyl nalezen"
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.vasedomena.cz",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.vasedomena.cz",
  "ttl": "auto",
  "status": "missing",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": "Nebyly nalezeny žádné CNAME záznamy na tr.vasedomena.cz"
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.vasedomena.cz",
  "ttl": "auto",
  "status": "missing",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": "Nebyly nalezeny žádné MX záznamy na inbound.vasedomena.cz"
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 401,
"message": "Neautorizováno"
}
}

{
"error": {
"code": 404,
"message": "Doména nebyla nalezena"
}
}

Stav DNS záznamů

Pole dns_records obsahuje podrobné informace o každém DNS záznamu požadovaném pro doménu:

Pole	Typ	Popis
`required`	boolean	Zda je tento DNS záznam vyžadován pro ověření
`type`	string	Typ DNS záznamu (MX, TXT, CNAME)
`name`	string	Název hostitele pro DNS záznam
`ttl`	string	Doba života DNS záznamu
`status`	string	Stav ověření: `ok`, `pending`, `failed`, `missing`
`value`	string	Hodnota, která by měla být nastavena pro tento DNS záznam
`priority`	number/null	Priorita pro MX záznamy, null pro ostatní
`error`	string/null	Chybová zpráva, pokud ověření selhalo

Proces ověření

Endpoint zkontroluje všechny požadované DNS záznamy (MX, SPF, DKIM)
Volitelný DMARC záznam je také zkontrolován, ale není vyžadován pro ověření
Doména je považována za ověřenou pouze tehdy, když všechny požadované záznamy projdou kontrolou
Časové razítko verified_at je nastaveno, když všechny požadované kontroly projdou
Stavy jednotlivých záznamů jsou uloženy v poli dns_records

Aktualizace domény

Aktualizujte existující doménu ve vašem Emailit účtu.

POST/domains/{id}

Parametry cesty

idstringRequired

ID domény, kterou chcete aktualizovat.

Tělo požadavku

track_loadsboolean

Zda sledovat načítání e-mailů pro tuto doménu (true/false).

track_clicksboolean

Zda sledovat kliknutí v e-mailech pro tuto doménu (true/false).

tracking_keystring

Vlastní klíč subdomény pro sledovací CNAME záznam (výchozí: null). Pokud je nastaven, sledovací CNAME použije tuto hodnotu místo výchozího go.

inbound_keystring

Vlastní klíč subdomény pro příchozí MX záznam (výchozí: null). Pokud je nastaven, příchozí MX použije tuto hodnotu místo výchozího inbound.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890', {
method: 'PATCH',
headers: {
'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
'Content-Type': 'application/json'
},
body: JSON.stringify({
track_loads: true,
track_clicks: false
})
});

const result = await response.json();

<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => 'https://api.emailit.com/v2/domains/sd_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'PATCH',
CURLOPT_POSTFIELDS => json_encode([
'track_loads' => true,
'track_clicks' => false
]),
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.patch(
'https://api.emailit.com/v2/domains/sd_1234567890',
headers={
    'Authorization': 'Bearer em_test_51RxCWJ...vS00p61e0qRE',
    'Content-Type': 'application/json'
},
json={
    'track_loads': True,
    'track_clicks': False
}
)

result = response.json()
print(result)

require 'net/http'
require 'json'

uri = URI('https://api.emailit.com/v2/domains/sd_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(uri)
request['Authorization'] = 'Bearer em_test_51RxCWJ...vS00p61e0qRE'
request['Content-Type'] = 'application/json'
request.body = {
track_loads: true,
track_clicks: false
}.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/domains/sd_1234567890"

data := map[string]interface{}{
    "track_loads": true,
    "track_clicks": false,
}

jsonData, _ := json.Marshal(data)

req, _ := http.NewRequest("PATCH", 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
    .patch("https://api.emailit.com/v2/domains/sd_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .json(&json!({
        "track_loads": true,
        "track_clicks": false
    }))
    .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 UpdateDomain {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    String jsonBody = "{\"track_loads\":true,\"track_clicks\":false}";
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains/sd_1234567890"))
        .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
        .header("Content-Type", "application/json")
        .method("PATCH", 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 UpdateDomain
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var data = new { track_loads = true, track_clicks = false };
        var json = JsonConvert.SerializeObject(data);
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        
        var request = new HttpRequestMessage(new HttpMethod("PATCH"), 
            "https://api.emailit.com/v2/domains/sd_1234567890")
        {
            Content = content
        };
        
        var response = await client.SendAsync(request);
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

curl -X PATCH https://api.emailit.com/v2/domains/sd_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json" \
-d '{
"track_loads": true,
"track_clicks": false
}'

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.vasedomena.cz",
"verification_token": "abc123def456",
"verification_method": "dns",
"verified_at": "2021-01-01T12:00:00Z",
"dkim_identifier_string": "emailit._domainkey",
"dns_checked_at": "2021-01-01T12:00:00Z",
"spf_status": "ok",
"spf_error": null,
"dkim_status": "ok",
"dkim_error": null,
"mx_status": "ok",
"mx_error": null,
"return_path_status": "ok",
"return_path_error": null,
"dmarc_status": "ok",
"dmarc_error": null,
"tracking_status": "ok",
"tracking_error": null,
"inbound_status": "ok",
"inbound_error": null,
"track_loads": 1,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "go.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.vasedomena.cz",
  "ttl": "auto",
  "status": "ok",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": null
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 400,
"message": "Neplatný požadavek"
}
}

{
"error": {
"code": 404,
"message": "Doména nebyla nalezena"
}
}

{
"error": {
"code": 409,
"message": "Konflikt"
}
}

Seznam domén

Načte seznam všech domén ve vašem Emailit účtu.

GET/domains

Parametry dotazu

pageinteger

Číslo stránky pro stránkování (minimum: 1).

limitinteger

Počet domén k vrácení (minimum: 1, maximum: 100).

const response = await fetch('https://api.emailit.com/v2/domains?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/domains?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 chyba #:" . $err;
} else {
$result = json_decode($response, true);
print_r($result);
}

import requests

response = requests.get(
'https://api.emailit.com/v2/domains',
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/domains?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/domains"
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/domains")
    .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 ListDomains {
public static void main(String[] args) throws Exception {
    HttpClient client = HttpClient.newHttpClient();
    
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create("https://api.emailit.com/v2/domains?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 ListDomains
{
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/domains?page=1&limit=10");
        
        var result = await response.Content.ReadAsStringAsync();
        Console.WriteLine(result);
    }
}
}

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

{
"data": [
{
  "id": 1234567890,
  "uuid": "sd_1234567890",
  "name": "mail.vasedomena.cz",
  "track_loads": true,
  "track_clicks": true,
  "created_at": "2021-01-01T00:00:00Z",
  "updated_at": "2021-01-01T00:00:00Z"
},
{
  "id": 987654321,
  "uuid": "sd_0987654321",
  "name": "mail2.vasedomena.cz",
  "track_loads": true,
  "track_clicks": true,
  "created_at": "2021-01-02T00:00:00Z",
  "updated_at": "2021-01-02T00:00:00Z"
}
],
"next_page_url": "https://api.emailit.com/v2/domains?page=2&limit=10",
"previous_page_url": null
}

{
"error": {
"code": 401,
"message": "Neautorizováno"
}
}

Smazání domény

Smažte doménu z vašeho Emailit účtu.

DELETE/domains/{id}

Parametry cesty

idstringRequired

ID domény, kterou chcete smazat.

const response = await fetch('https://api.emailit.com/v2/domains/sd_1234567890', {
method: 'DELETE',
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/domains/sd_1234567890',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => '',
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => 'DELETE',
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.delete(
'https://api.emailit.com/v2/domains/sd_1234567890',
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/domains/sd_1234567890')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Delete.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 (
"fmt"
"net/http"
)

func main() {
url := "https://api.emailit.com/v2/domains/sd_1234567890"

req, _ := http.NewRequest("DELETE", 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()

fmt.Println("Stav:", resp.Status)
}

use reqwest;

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

let response = client
    .delete("https://api.emailit.com/v2/domains/sd_1234567890")
    .header("Authorization", "Bearer em_test_51RxCWJ...vS00p61e0qRE")
    .header("Content-Type", "application/json")
    .send()
    .await?;

println!("Stav: {}", response.status());

Ok(())
}

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

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

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

public class DeleteDomain
{
public static async Task Main()
{
    using (var client = new HttpClient())
    {
        client.DefaultRequestHeaders.Add("Authorization", 
            "Bearer em_test_51RxCWJ...vS00p61e0qRE");
        
        var response = await client.DeleteAsync(
            "https://api.emailit.com/v2/domains/sd_1234567890");
        
        Console.WriteLine("Stav: " + response.StatusCode);
    }
}
}

curl -X DELETE https://api.emailit.com/v2/domains/sd_1234567890 \
-H "Authorization: Bearer em_test_51RxCWJ...vS00p61e0qRE" \
-H "Content-Type: application/json"

{
"object": "domain",
"id": 1234567890,
"name": "mail.yourdomain.com",
"deleted": true
}

{
"error": {
"code": 404,
"message": "Doména nebyla nalezena"
}
}