Crea Dominio

Crea un dominio tramite l’API di Emailit.

POST/domains

Corpo della Richiesta

namestringRequired

Il nome del dominio, nel formato mail.tuodominio.com.

track_loadsboolean

Se tracciare le aperture delle email per questo dominio (predefinito: false).

track_clicksboolean

Se tracciare i clic delle email per questo dominio (predefinito: 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.tuodominio.com',
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.tuodominio.com',
'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 "Errore cURL #:" . $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.tuodominio.com',
    '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.tuodominio.com',
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.tuodominio.com",
    "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.tuodominio.com",
        "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.tuodominio.com\",\"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.tuodominio.com", 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.tuodominio.com",
"track_loads": false,
"track_clicks": false
}'

{
"object": "domain",
"id": 1234567890,
"uuid": "sd_1234567890",
"name": "mail.tuodominio.com",
"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.tuodominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tuodominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tuodominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tuodominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tuodominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tuodominio.com",
  "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": "Richiesta non valida"
}
}

{
"error": {
"code": 409,
"message": "Il dominio esiste già"
},
"existing": {
"object": "domain",
"id": 1234567890,
"name": "mail.tuodominio.com"
}
}

Ottieni Dominio

Recupera le informazioni relative a un dominio specifico nel tuo account Emailit.

GET/domains/{id}

Parametri del Percorso

idstringRequired

L’ID del dominio da recuperare.

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 "Errore cURL #:" . $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.tuodominio.com",
"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.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tuodominio.com",
  "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": "Non autorizzato"
}
}

{
"error": {
"code": 404,
"message": "Dominio non trovato"
}
}

Verifica Dominio

Verifica che i record DNS necessari siano stati configurati correttamente per un dominio. Questo endpoint controlla tutti i record DNS (MX, SPF, DKIM e DMARC) e aggiorna lo stato di verifica del dominio.

POST/domains/{id}/verify

Parametri del Percorso

idstringRequired

L’ID del dominio da verificare.

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 "Errore cURL #:" . $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.tuodominio.com",
"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.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tuodominio.com",
  "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.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tuodominio.com",
  "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.tuodominio.com",
"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": "Record SPF non trovato",
"dkim_status": "failed",
"dkim_error": "Record DKIM non trovato",
"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": "Non sono presenti record CNAME per tr.tuodominio.com",
"inbound_status": "missing",
"inbound_error": "Non sono presenti record MX per inbound.tuodominio.com",
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tuodominio.com",
  "ttl": "auto",
  "status": "failed",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": "Record SPF non trovato"
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tuodominio.com",
  "ttl": "auto",
  "status": "failed",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA....",
  "priority": null,
  "error": "Record DKIM non trovato"
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tuodominio.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.tuodominio.com",
  "ttl": "auto",
  "status": "missing",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": "Non sono presenti record CNAME per tr.tuodominio.com"
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tuodominio.com",
  "ttl": "auto",
  "status": "missing",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": "Non sono presenti record MX per inbound.tuodominio.com"
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 401,
"message": "Non autorizzato"
}
}

{
"error": {
"code": 404,
"message": "Dominio non trovato"
}
}

Stato dei Record DNS

L’array dns_records contiene informazioni dettagliate su ogni record DNS richiesto per il dominio:

Campo	Tipo	Descrizione
`required`	boolean	Indica se questo record DNS è obbligatorio per la verifica
`type`	string	Tipo di record DNS (MX, TXT, CNAME)
`name`	string	Il nome host per il record DNS
`ttl`	string	Time to live per il record DNS
`status`	string	Stato di verifica: `ok`, `pending`, `failed`, `missing`
`value`	string	Il valore che dovrebbe essere impostato per questo record DNS
`priority`	number/null	Priorità per i record MX, null per gli altri
`error`	string/null	Messaggio di errore se la verifica è fallita

Processo di Verifica

L’endpoint controlla tutti i record DNS obbligatori (MX, SPF, DKIM)
Il record DMARC opzionale viene anch’esso controllato ma non è necessario per la verifica
Il dominio viene considerato verificato solo quando tutti i record obbligatori sono validi
Il timestamp verified_at viene impostato quando tutti i controlli obbligatori sono superati
Gli stati dei singoli record vengono memorizzati nell’array dns_records

Aggiorna Dominio

Aggiorna un dominio esistente nel tuo account Emailit.

POST/domains/{id}

Parametri del Percorso

idstringRequired

L’ID del dominio da aggiornare.

Corpo della Richiesta

track_loadsboolean

Se tracciare le aperture delle email per questo dominio (true/false).

track_clicksboolean

Se tracciare i clic delle email per questo dominio (true/false).

tracking_keystring

Chiave personalizzata del sottodominio per il record CNAME di tracciamento (predefinito: null). Quando impostata, il CNAME di tracciamento utilizzerà questo valore invece del predefinito go.

inbound_keystring

Chiave personalizzata del sottodominio per il record MX in entrata (predefinito: null). Quando impostata, il MX in entrata utilizzerà questo valore invece del predefinito 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 "Errore cURL #:" . $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.tuodominio.com",
"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.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "go.tuodominio.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.tuodominio.com",
  "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": "Richiesta non valida"
}
}

{
"error": {
"code": 404,
"message": "Dominio non trovato"
}
}

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

Elencare Domini

Recupera un elenco di tutti i domini nel tuo account Emailit.

GET/domains

Parametri di Query

pageinteger

Numero di pagina per la paginazione (minimo: 1).

limitinteger

Numero di domini da restituire (minimo: 1, massimo: 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 "Errore cURL #:" . $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.tuodominio.com",
  "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.tuodominio.com",
  "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": "Non autorizzato"
}
}

Elimina Dominio

Elimina un dominio dal tuo account Emailit.

DELETE/domains/{id}

Parametri del Percorso

idstringRequired

L’ID del dominio da eliminare.

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 "Errore cURL #:" . $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("Stato:", 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!("Stato: {}", 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("Stato: " + 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("Stato: " + 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": "Dominio non trovato"
}
}

Crea Dominio

Corpo della Richiesta

Ottieni Dominio

Parametri del Percorso

Verifica Dominio

Parametri del Percorso

Stato dei Record DNS

Processo di Verifica

Aggiorna Dominio

Parametri del Percorso

Corpo della Richiesta

Elencare Domini

Parametri di Query

Elimina Dominio

Parametri del Percorso

Localizzato tramite IA