Domain erstellen

Erstellen Sie eine Domain über die Emailit API.

POST/domains

Request Body

namestringRequired

Der Name der Domain im Format mail.ihredomain.com.

track_loadsboolean

Ob E-Mail-Öffnungen für diese Domain verfolgt werden sollen (Standard: false).

track_clicksboolean

Ob E-Mail-Klicks für diese Domain verfolgt werden sollen (Standard: 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.ihredomain.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.ihredomain.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 "cURL Fehler #:" . $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.ihredomain.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.ihredomain.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.ihredomain.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.ihredomain.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.ihredomain.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.ihredomain.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.ihredomain.com",
"track_loads": false,
"track_clicks": false
}'

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

{
"error": {
"code": 409,
"message": "Domain bereits vorhanden"
},
"existing": {
"object": "domain",
"id": 1234567890,
"name": "mail.ihredomain.com"
}
}

Domain abrufen

Rufen Sie Informationen zu einer bestimmten Domain in Ihrem Emailit-Konto ab.

GET/domains/{id}

Pfad-Parameter

idstringRequired

Die ID der Domain, die abgerufen werden soll.

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

{
"error": {
"code": 404,
"message": "Domain nicht gefunden"
}
}

Domain verifizieren

Überprüft, ob die erforderlichen DNS-Einträge für eine Domain korrekt konfiguriert wurden. Dieser Endpunkt prüft alle DNS-Einträge (MX, SPF, DKIM und DMARC) und aktualisiert den Verifizierungsstatus der Domain.

POST/domains/{id}/verify

Pfad-Parameter

idstringRequired

Die ID der zu verifizierenden Domain.

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-Fehler #:" . $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.ihredomain.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.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.ihredomain.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.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.ihredomain.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.ihredomain.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": "SPF-Eintrag nicht gefunden",
"dkim_status": "failed",
"dkim_error": "DKIM-Eintrag nicht gefunden",
"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": "Keine CNAME-Einträge unter tr.ihredomain.com vorhanden",
"inbound_status": "missing",
"inbound_error": "Keine MX-Einträge unter inbound.ihredomain.com vorhanden",
"track_loads": 0,
"track_clicks": 0,
"dns_records": [
{
  "required": true,
  "type": "MX",
  "name": "mail.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.ihredomain.com",
  "ttl": "auto",
  "status": "failed",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": "SPF-Eintrag nicht gefunden"
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.ihredomain.com",
  "ttl": "auto",
  "status": "failed",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA....",
  "priority": null,
  "error": "DKIM-Eintrag nicht gefunden"
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.ihredomain.com",
  "ttl": "auto",
  "status": "pending",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "tr.ihredomain.com",
  "ttl": "auto",
  "status": "missing",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": "Keine CNAME-Einträge unter tr.ihredomain.com vorhanden"
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.ihredomain.com",
  "ttl": "auto",
  "status": "missing",
  "value": "inbound.emailitmail.com",
  "priority": 10,
  "error": "Keine MX-Einträge unter inbound.ihredomain.com vorhanden"
}
],
"created_at": "2021-01-01T00:00:00Z",
"updated_at": "2021-01-01T12:00:00Z"
}

{
"error": {
"code": 401,
"message": "Nicht autorisiert"
}
}

{
"error": {
"code": 404,
"message": "Domain nicht gefunden"
}
}

DNS-Eintrag Status

Das Array dns_records enthält detaillierte Informationen zu jedem DNS-Eintrag, der für die Domain erforderlich ist:

Feld	Typ	Beschreibung
`required`	boolean	Ob dieser DNS-Eintrag für die Verifizierung erforderlich ist
`type`	string	DNS-Eintragstyp (MX, TXT, CNAME)
`name`	string	Der Hostname für den DNS-Eintrag
`ttl`	string	Time-to-Live für den DNS-Eintrag
`status`	string	Verifizierungsstatus: `ok`, `pending`, `failed`, `missing`
`value`	string	Der Wert, der für diesen DNS-Eintrag gesetzt werden sollte
`priority`	number/null	Priorität für MX-Einträge, null für andere
`error`	string/null	Fehlermeldung, falls die Verifizierung fehlgeschlagen ist

Verifizierungsprozess

Der Endpunkt überprüft alle erforderlichen DNS-Einträge (MX, SPF, DKIM)
Der optionale DMARC-Eintrag wird ebenfalls geprüft, ist aber nicht für die Verifizierung erforderlich
Die Domain gilt nur dann als verifiziert, wenn alle erforderlichen Einträge erfolgreich geprüft wurden
Der Zeitstempel verified_at wird gesetzt, wenn alle erforderlichen Prüfungen erfolgreich waren
Die Status der einzelnen Einträge werden im Array dns_records gespeichert

Domain aktualisieren

Aktualisieren Sie eine bestehende Domain in Ihrem Emailit-Konto.

POST/domains/{id}

Pfad-Parameter

idstringRequired

Die ID der zu aktualisierenden Domain.

Request Body

track_loadsboolean

Ob E-Mail-Öffnungen für diese Domain verfolgt werden sollen (true/false).

track_clicksboolean

Ob E-Mail-Klicks für diese Domain verfolgt werden sollen (true/false).

tracking_keystring

Benutzerdefinierter Subdomain-Schlüssel für den Tracking-CNAME-Eintrag (Standard: null). Wenn gesetzt, verwendet der Tracking-CNAME diesen Wert anstelle des Standard-Wertes go.

inbound_keystring

Benutzerdefinierter Subdomain-Schlüssel für den Inbound-MX-Eintrag (Standard: null). Wenn gesetzt, verwendet der Inbound-MX diesen Wert anstelle des Standard-Wertes 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-Fehler #:" . $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.ihredomain.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.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "feedback-smtp.ffdc-1.emailit.com",
  "priority": 10,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "mail.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=spf1 include:_spf.emailit.com ~all",
  "priority": null,
  "error": null
},
{
  "required": true,
  "type": "TXT",
  "name": "emailit._domainkey.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DKIM1; t=s; h=sha256; p=MIGfMA0G...",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "TXT",
  "name": "_dmarc.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "v=DMARC1; p=none;",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "CNAME",
  "name": "go.ihredomain.com",
  "ttl": "auto",
  "status": "ok",
  "value": "go.emailitmail.com",
  "priority": null,
  "error": null
},
{
  "required": false,
  "type": "MX",
  "name": "inbound.ihredomain.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": "Ungültige Anfrage"
}
}

{
"error": {
"code": 404,
"message": "Domain nicht gefunden"
}
}

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

Domains auflisten

Rufen Sie eine Liste aller Domains in Ihrem Emailit-Konto ab.

GET/domains

Abfrageparameter

pageinteger

Seitennummer für die Paginierung (Minimum: 1).

limitinteger

Anzahl der zurückzugebenden Domains (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-Fehler #:" . $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.ihredomain.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.ihredomain.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": "Nicht autorisiert"
}
}

Domain löschen

Löschen Sie eine Domain aus Ihrem Emailit-Konto.

DELETE/domains/{id}

Pfad-Parameter

idstringRequired

Die ID der zu löschenden Domain.

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-Fehler #:" . $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("Status:", 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!("Status: {}", 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("Status: " + 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("Status: " + 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": "Domain nicht gefunden"
}
}

Domain erstellen

Request Body

Domain abrufen

Pfad-Parameter

Domain verifizieren

Pfad-Parameter

DNS-Eintrag Status

Verifizierungsprozess

Domain aktualisieren

Pfad-Parameter

Request Body

Domains auflisten

Abfrageparameter

Domain löschen

Pfad-Parameter

Lokalisiert durch KI