Domains (API) | Accountmaker 文档

Operations related to Domains.

GET/api/accounts/{account_id}/domains

List all custom domains registered under an account. Returns DNS verification status and DKIM configuration. More Email

Responses

200application/json

schemaobject

dataarrayrequired

itemallOfrequired

Variant

A custom domain registered to an account for branding and email deliverability.

DomainDomain

Nested fields truncated. Expand to continue inline, or use the model link.

A custom domain registered to an account for branding and email deliverability.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/accounts/acc123/domains?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/accounts/{account_id}/domains

Body application/json

hostnamestringrequired

The hostname

Responses

200application/json

schemaobject

dataDomainrequired

A custom domain registered to an account for branding and email deliverability.

idstringrequired

Unique identifier for a domain.

account_idstringrequired

Unique identifier for an account.

hostnamestringrequired

The hostname

txt_verification_tokenstringrequired

Token for DNS TXT verification. Set this as a TXT record at _am.<hostname>

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/accounts/acc123/domains" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"hostname":"example.com"}'

const payload = {"hostname":"example.com"};
const url = "${BASE_URL}/api/accounts/acc123/domains";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"hostname":"example.com"};
const url = "${BASE_URL}/api/accounts/acc123/domains";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"hostname":"example.com"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/domains",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"hostname":"example.com"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/domains",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"hostname":"example.com"};
const { body } = await request("${BASE_URL}/api/accounts/acc123/domains", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"hostname":"example.com"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/accounts/acc123/domains", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"hostname":"example.com"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/accounts/acc123/domains", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"hostname":"example.com"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/accounts/acc123/domains", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"hostname":"example.com"}
uri = URI("${BASE_URL}/api/accounts/acc123/domains")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"hostname":"example.com"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/accounts/acc123/domains", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/accounts/acc123/domains");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"hostname\":\"example.com\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/accounts/{account_id}/domains/search

Search account domains using Lucene-style query syntax.

Supported fields:

hostname: - Search domain hostname

Operators:

AND - Both conditions must match
OR - Either condition must match
* - Wildcard (e.g., hostname:*.example.com)

Examples:

hostname:mail
hostname:*.example.com

Optionally filter associated application-domain links by application_ids and link_types. Results include matching applicationDomains rows so consumers can see attachment target and link type.

More Email

Body application/json

querystringrequired

Lucene-style search query. Supports field:value syntax (hostname:), wildcards (*), and boolean operators (AND, OR). Example: 'hostname:*example.com'

limitinteger

Maximum number of results to return (default: 20, max: 100)

offsetinteger

Number of results to skip for pagination

sort

application_domainsobject

application_idsarray

Filter results to domains linked to one of these application IDs

itemstringrequired

Unique identifier for an application.

link_typesarray

Filter linked application domains by link type (mx or cname)

itemrequired

Responses

200application/json

schemaobject

dataarrayrequired

itemallOfrequired

Variant

A custom domain registered to an account for branding and email deliverability.

DomainDomain

Nested fields truncated. Expand to continue inline, or use the model link.

A custom domain registered to an account for branding and email deliverability.

Option 2object

Nested fields truncated. Expand to continue inline, or use the model link.

metaobjectrequired

querystringrequired

totalnumberrequired

limitnumberrequired

offsetnumberrequired

sortrequired

linksobjectrequired

selfstringrequired

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/accounts/acc123/domains/search" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}}'

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}};
const url = "${BASE_URL}/api/accounts/acc123/domains/search";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}};
const url = "${BASE_URL}/api/accounts/acc123/domains/search";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/domains/search",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/accounts/acc123/domains/search",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}};
const { body } = await request("${BASE_URL}/api/accounts/acc123/domains/search", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/accounts/acc123/domains/search", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/accounts/acc123/domains/search", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/accounts/acc123/domains/search", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}}
uri = URI("${BASE_URL}/api/accounts/acc123/domains/search")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"query":"string","limit":123,"offset":123,"sort":"created_at:desc,id:asc","application_domains":{"application_ids":["app2ABC123"],"link_types":["mx"]}};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/accounts/acc123/domains/search", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/accounts/acc123/domains/search");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"query\":\"string\",\"limit\":123,\"offset\":123,\"sort\":\"created_at:desc,id:asc\",\"application_domains\":{\"application_ids\":[\"app2ABC123\"],\"link_types\":[\"mx\"]}}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/domains

List domain links for an application. More

Responses

200application/json

schemaobject

dataarrayrequired

itemobjectrequired

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

link_typerequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/domains" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/domains";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/domains";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/domains", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/domains", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/domains", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/domains", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/domains")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/domains", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/domains");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/applications/{application_id}/domains

Create a domain link for an application. More

Body application/json

domain_idstringrequired

Unique identifier for a domain.

link_typerequired

Responses

200application/json

schemaobject

dataobjectrequired

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

link_typerequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/applications/app123/domains" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"domain_id":"hst456","link_type":"mx"}'

const payload = {"domain_id":"hst456","link_type":"mx"};
const url = "${BASE_URL}/api/applications/app123/domains";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"domain_id":"hst456","link_type":"mx"};
const url = "${BASE_URL}/api/applications/app123/domains";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"domain_id":"hst456","link_type":"mx"};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/domains",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"domain_id":"hst456","link_type":"mx"};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/domains",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"domain_id":"hst456","link_type":"mx"};
const { body } = await request("${BASE_URL}/api/applications/app123/domains", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"domain_id":"hst456","link_type":"mx"}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/applications/app123/domains", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"domain_id":"hst456","link_type":"mx"}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/applications/app123/domains", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"domain_id":"hst456","link_type":"mx"}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/applications/app123/domains", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"domain_id":"hst456","link_type":"mx"}
uri = URI("${BASE_URL}/api/applications/app123/domains")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"domain_id":"hst456","link_type":"mx"};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/applications/app123/domains", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/applications/app123/domains");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"domain_id\":\"hst456\",\"link_type\":\"mx\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/applications/{application_id}/domains/{domain_id}

Delete an application-domain link. More

Responses

204

Application-domain link deleted

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/applications/app123/domains/hst456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/domains/hst456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/domains/hst456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/applications/app123/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/applications/app123/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/applications/app123/domains/hst456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/applications/app123/domains/hst456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/applications/app123/domains/hst456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/applications/app123/domains/hst456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/applications/app123/domains/hst456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/domains/{domain_id}

Get a domain link for an application. More

Responses

200application/json

schemaobject

dataobjectrequired

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

link_typerequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/domains/hst456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/domains/hst456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/domains/hst456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/domains/hst456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/domains/hst456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/domains/hst456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/domains/hst456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/domains/hst456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/applications/{application_id}/domains/{domain_id}

Update an application-domain link. More

Body application/json

link_type

Responses

200application/json

schemaobject

dataobjectrequired

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

link_typerequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/applications/app123/domains/hst456" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"link_type":"mx"}'

const payload = {"link_type":"mx"};
const url = "${BASE_URL}/api/applications/app123/domains/hst456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"link_type":"mx"};
const url = "${BASE_URL}/api/applications/app123/domains/hst456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"link_type":"mx"};
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/applications/app123/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"link_type":"mx"};
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/applications/app123/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"link_type":"mx"};
const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"link_type":"mx"}
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/applications/app123/domains/hst456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"link_type":"mx"}
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/applications/app123/domains/hst456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"link_type":"mx"}`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/applications/app123/domains/hst456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"link_type":"mx"}
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"link_type":"mx"};
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/applications/app123/domains/hst456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/applications/app123/domains/hst456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"link_type\":\"mx\"}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/domains/{domain_id}/mail-forwards

List mail forwards for an application-domain link. More

Responses

200application/json

schemaobject

dataarrayrequired

itemobjectrequired

idstringrequired

Unique identifier for a mail forwarding rule.

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

original_toRfcEmailAddressrequired

A valid, normalized RFC email address.

forward_toRfcEmailAddressrequired

A valid, normalized RFC email address.

is_activebooleanrequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/applications/{application_id}/domains/{domain_id}/mail-forwards

Create a mail forward for an application-domain link. More

Body application/json

original_toRfcEmailAddressrequired

A valid, normalized RFC email address.

forward_toRfcEmailAddressrequired

A valid, normalized RFC email address.

is_activeboolean

Responses

200application/json

schemaobject

dataobjectrequired

idstringrequired

Unique identifier for a mail forwarding rule.

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

original_toRfcEmailAddressrequired

A valid, normalized RFC email address.

forward_toRfcEmailAddressrequired

A valid, normalized RFC email address.

is_activebooleanrequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"original_to":"value","forward_to":"value","is_active":true}'

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"original_to":"value","forward_to":"value","is_active":true};
const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"original_to":"value","forward_to":"value","is_active":true}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"original_to":"value","forward_to":"value","is_active":true}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"original_to":"value","forward_to":"value","is_active":true}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"original_to":"value","forward_to":"value","is_active":true}
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"original_to":"value","forward_to":"value","is_active":true};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"original_to\":\"value\",\"forward_to\":\"value\",\"is_active\":true}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/applications/{application_id}/domains/{domain_id}/mail-forwards/{mail_forward_id}

Delete a mail forward. More

Responses

204

Mail forward deleted

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/applications/{application_id}/domains/{domain_id}/mail-forwards/{mail_forward_id}

Get a mail forward by ID. More

Responses

200application/json

schemaobject

dataobjectrequired

idstringrequired

Unique identifier for a mail forwarding rule.

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

original_toRfcEmailAddressrequired

A valid, normalized RFC email address.

forward_toRfcEmailAddressrequired

A valid, normalized RFC email address.

is_activebooleanrequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/applications/{application_id}/domains/{domain_id}/mail-forwards/{mail_forward_id}

Update a mail forward. More

Body application/json

original_toRfcEmailAddress

A valid, normalized RFC email address.

forward_toRfcEmailAddress

A valid, normalized RFC email address.

is_activeboolean

Responses

200application/json

schemaobject

dataobjectrequired

idstringrequired

Unique identifier for a mail forwarding rule.

resource_idstringrequired

Unique identifier for an application.

domain_idstringrequired

Unique identifier for a domain.

original_toRfcEmailAddressrequired

A valid, normalized RFC email address.

forward_toRfcEmailAddressrequired

A valid, normalized RFC email address.

is_activebooleanrequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"original_to":"value","forward_to":"value","is_active":true}'

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const url = "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"original_to":"value","forward_to":"value","is_active":true};
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"original_to":"value","forward_to":"value","is_active":true};
const { body } = await request("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"original_to":"value","forward_to":"value","is_active":true}
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"original_to":"value","forward_to":"value","is_active":true}
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"original_to":"value","forward_to":"value","is_active":true}`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"original_to":"value","forward_to":"value","is_active":true}
uri = URI("${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"original_to":"value","forward_to":"value","is_active":true};
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/applications/app123/domains/hst456/mail-forwards/mfw456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"original_to\":\"value\",\"forward_to\":\"value\",\"is_active\":true}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/dkim-keys/{dkim_key_id}

Delete a DKIM key.

Warning: Deleting an active DKIM key will cause DKIM signing to fail for outbound emails from this hostname until a new key is created and activated.

DNS Cleanup: After deletion, you may want to remove the corresponding DNS TXT record to avoid confusion.

Responses

200application/json

schemaobject

dataobjectrequired

deletedrequired

idstringrequired

Unique identifier for a DKIM key.

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/dkim-keys/dkm456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/dkim-keys/dkm456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/dkim-keys/dkm456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/dkim-keys/dkm456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/dkim-keys/dkm456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/dkim-keys/dkm456", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/dkim-keys/dkm456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/dkim-keys/dkm456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/dkim-keys/dkm456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/dkim-keys/dkm456")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/dkim-keys/dkm456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/dkim-keys/dkm456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/dkim-keys/{dkim_key_id}

Get a DKIM key by its ID. Returns public information and DNS configuration details. Private keys are never exposed. More

Responses

200application/json

schemaobject

dataDkimKeyResponserequired

A DKIM key for API responses. Includes computed DNS record information needed for setup, excludes private key material.

idstringrequired

Unique identifier for a DKIM key.

domain_idstringrequired

Unique identifier for a domain.

selectorstringrequired

The DKIM selector (s= tag)

is_activebooleanrequired

dns_record_namestringrequired

The DNS TXT record name (selector._domainkey.hostname)

dns_record_valuestringrequired

The DNS TXT record value to configure

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/dkim-keys/dkm456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/dkim-keys/dkm456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/dkim-keys/dkm456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/dkim-keys/dkm456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/dkim-keys/dkm456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/dkim-keys/dkm456", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/dkim-keys/dkm456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/dkim-keys/dkm456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/dkim-keys/dkm456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/dkim-keys/dkm456")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/dkim-keys/dkm456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/dkim-keys/dkm456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/dkim-keys/{dkim_key_id}

Update a DKIM key’s properties.

Activation: Setting is_active: true will activate this key. Only one key can be active per hostname, so activating a key may fail if another key is already active. Deactivate the existing key first.

Note: The selector and private key cannot be changed. Create a new key if you need different values.

Body application/json

is_activeboolean

Set to true to activate this key (deactivates any other active key for the hostname), or false to deactivate.

Responses

200application/json

schemaobject

dataDkimKeyResponserequired

A DKIM key for API responses. Includes computed DNS record information needed for setup, excludes private key material.

idstringrequired

Unique identifier for a DKIM key.

domain_idstringrequired

Unique identifier for a domain.

selectorstringrequired

The DKIM selector (s= tag)

is_activebooleanrequired

dns_record_namestringrequired

The DNS TXT record name (selector._domainkey.hostname)

dns_record_valuestringrequired

The DNS TXT record value to configure

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/dkim-keys/dkm456" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"is_active":true}'

const payload = {"is_active":true};
const url = "${BASE_URL}/api/dkim-keys/dkm456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"is_active":true};
const url = "${BASE_URL}/api/dkim-keys/dkm456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"is_active":true};
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/dkim-keys/dkm456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"is_active":true};
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/dkim-keys/dkm456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"is_active":true};
const { body } = await request("${BASE_URL}/api/dkim-keys/dkm456", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"is_active":true}
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/dkim-keys/dkm456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"is_active":true}
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/dkim-keys/dkm456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"is_active":true}`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/dkim-keys/dkm456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"is_active":true}
uri = URI("${BASE_URL}/api/dkim-keys/dkm456")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"is_active":true};
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/dkim-keys/dkm456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/dkim-keys/dkm456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"is_active\":true}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DELETE/api/domains/{domain_id}

Delete a domain.

Warning: Deleting a domain will also delete all associated DKIM keys and domain checks.

Responses

204

Domain deleted successfully

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X DELETE \\
  "${BASE_URL}/api/domains/hst456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/domains/hst456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/domains/hst456";
const response = await fetch(url, {
  method: "DELETE",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "delete",
  url: "${BASE_URL}/api/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "delete",
  url: "${BASE_URL}/api/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/domains/hst456", {
  method: "DELETE",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "DELETE", \
    "${BASE_URL}/api/domains/hst456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "DELETE", \
        "${BASE_URL}/api/domains/hst456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("DELETE", "${BASE_URL}/api/domains/hst456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/domains/hst456")
request = Net::HTTP::Delete.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("DELETE", "${BASE_URL}/api/domains/hst456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Delete, "${BASE_URL}/api/domains/hst456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/domains/{domain_id}

Retrieve a domain by its ID. Returns DNS verification status and associated DKIM keys. Used for email authentication and custom domain setup. More Email

Responses

200application/json

schemaobject

dataallOfrequired

Variant

A custom domain registered to an account for branding and email deliverability.

DomainDomain

A custom domain registered to an account for branding and email deliverability.

idstringrequired

Unique identifier for a domain.

account_idstringrequired

Unique identifier for an account.

hostnamestringrequired

The hostname

txt_verification_tokenstringrequired

Token for DNS TXT verification. Set this as a TXT record at _am.<hostname>

Option 2object

hostnameChecksarrayrequired

Nested fields truncated. Expand to continue inline, or use the model link.

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/domains/hst456" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/domains/hst456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/domains/hst456";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/domains/hst456", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/domains/hst456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/domains/hst456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/domains/hst456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/domains/hst456")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/domains/hst456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/domains/hst456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

PATCH/api/domains/{domain_id}

Update domain properties using JSON Merge Patch (RFC 7396). More Email

Body application/json

hostnamestring | null

The hostname

Responses

200application/json

schemaobject

dataDomainrequired

A custom domain registered to an account for branding and email deliverability.

idstringrequired

Unique identifier for a domain.

account_idstringrequired

Unique identifier for an account.

hostnamestringrequired

The hostname

txt_verification_tokenstringrequired

Token for DNS TXT verification. Set this as a TXT record at _am.<hostname>

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X PATCH \\
  "${BASE_URL}/api/domains/hst456" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '"value"'

const payload = "value";
const url = "${BASE_URL}/api/domains/hst456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = "value";
const url = "${BASE_URL}/api/domains/hst456";
const response = await fetch(url, {
  method: "PATCH",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = "value";
const response = await axios({
  method: "patch",
  url: "${BASE_URL}/api/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = "value";
const response: AxiosResponse = await axios({
  method: "patch",
  url: "${BASE_URL}/api/domains/hst456",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = "value";
const { body } = await request("${BASE_URL}/api/domains/hst456", {
  method: "PATCH",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = "value"
response = requests.request( \
    "PATCH", \
    "${BASE_URL}/api/domains/hst456", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = "value"
with httpx.Client() as client:
    response = client.request( \
        "PATCH", \
        "${BASE_URL}/api/domains/hst456", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`"value"`))

req, err := http.NewRequest("PATCH", "${BASE_URL}/api/domains/hst456", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = "value"
uri = URI("${BASE_URL}/api/domains/hst456")
request = Net::HTTP::Patch.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = "value";
$client = new Client();
$response = $client->request("PATCH", "${BASE_URL}/api/domains/hst456", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Patch, "${BASE_URL}/api/domains/hst456");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("\"value\"", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/domains/{domain_id}/checks

Run DNS verification checks for a domain. Verifies TXT ownership records, CNAME configuration, and DKIM key propagation. More Email

Body application/json

checksarrayrequired

itemrequired

Responses

200application/json

schemaobject

dataarrayrequired

itemobjectrequired

idstringrequired

Unique identifier for a hostname check.

domain_idstringrequired

Unique identifier for a domain.

check_typestringrequired

recordstringrequired

Record type and target checked (e.g. TXT _dmarc.example.com)

expectedstringrequired

observedstringrequired

okbooleanrequired

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/domains/hst456/checks" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"checks":["cname"]}'

const payload = {"checks":["cname"]};
const url = "${BASE_URL}/api/domains/hst456/checks";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"checks":["cname"]};
const url = "${BASE_URL}/api/domains/hst456/checks";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"checks":["cname"]};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/domains/hst456/checks",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"checks":["cname"]};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/domains/hst456/checks",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"checks":["cname"]};
const { body } = await request("${BASE_URL}/api/domains/hst456/checks", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"checks":["cname"]}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/domains/hst456/checks", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"checks":["cname"]}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/domains/hst456/checks", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"checks":["cname"]}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/domains/hst456/checks", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"checks":["cname"]}
uri = URI("${BASE_URL}/api/domains/hst456/checks")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"checks":["cname"]};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/domains/hst456/checks", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/domains/hst456/checks");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"checks\":[\"cname\"]}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/domains/{domain_id}/dkim-keys

List all DKIM keys for a domain. Returns DNS configuration info including record names and values. Private keys are never exposed. More Email

Responses

200application/json

schemaobject

dataarrayrequired

itemDkimKeyResponserequired

A DKIM key for API responses. Includes computed DNS record information needed for setup, excludes private key material.

idstringrequired

Unique identifier for a DKIM key.

domain_idstringrequired

Unique identifier for a domain.

selectorstringrequired

The DKIM selector (s= tag)

is_activebooleanrequired

dns_record_namestringrequired

The DNS TXT record name (selector._domainkey.hostname)

dns_record_valuestringrequired

The DNS TXT record value to configure

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the current page

nextstring

URL of the next page

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/domains/hst456/dkim-keys?limit=20&cursor=eyJpZCI6ImFjYzEyMyJ9");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

POST/api/domains/{domain_id}/dkim-keys

Create a new DKIM key for a domain.

Key Generation: If private_key_pem is not provided, a 2048-bit RSA key pair will be automatically generated.

DNS Setup: After creation, configure your DNS with the returned dns_record_name and dns_record_value as a TXT record.

Active Keys: Only one DKIM key can be active per domain. Creating a new active key will deactivate the previous one.

More Email

Body application/json

selectorstringrequired

The DKIM selector (s= tag). Common values: 'mail', 'dkim1', 'selector1'. Must be alphanumeric with optional hyphens.

private_key_pemstring

Optional RSA private key in PEM format. If not provided, a 2048-bit key will be generated.

is_activeboolean

Whether this key should be active. Only one key can be active per domain.

Responses

200application/json

schemaobject

dataDkimKeyResponserequired

A DKIM key for API responses. Includes computed DNS record information needed for setup, excludes private key material.

idstringrequired

Unique identifier for a DKIM key.

domain_idstringrequired

Unique identifier for a domain.

selectorstringrequired

The DKIM selector (s= tag)

is_activebooleanrequired

dns_record_namestringrequired

The DNS TXT record name (selector._domainkey.hostname)

dns_record_valuestringrequired

The DNS TXT record value to configure

created_atstringrequired

updated_atstringrequired

linksobjectrequired

selfstringrequired

URL of the created resource

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X POST \\
  "${BASE_URL}/api/domains/hst456/dkim-keys" \\
  -H "Authorization: Bearer ${API_TOKEN}" \\
  -H "Content-Type: application/json" \\
  -d '{"selector":"string","private_key_pem":"string","is_active":true}'

const payload = {"selector":"string","private_key_pem":"string","is_active":true};
const url = "${BASE_URL}/api/domains/hst456/dkim-keys";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
});

console.log(await response.json());

const payload = {"selector":"string","private_key_pem":"string","is_active":true};
const url = "${BASE_URL}/api/domains/hst456/dkim-keys";
const response = await fetch(url, {
  method: "POST",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  body: JSON.stringify(payload),
} as RequestInit);

console.log(await response.json());

const payload = {"selector":"string","private_key_pem":"string","is_active":true};
const response = await axios({
  method: "post",
  url: "${BASE_URL}/api/domains/hst456/dkim-keys",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

const payload = {"selector":"string","private_key_pem":"string","is_active":true};
const response: AxiosResponse = await axios({
  method: "post",
  url: "${BASE_URL}/api/domains/hst456/dkim-keys",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
    "Content-Type": "application/json",
  },
  data: payload,
});

console.log(response.data);

import { request } from "undici";

const bodyData = {"selector":"string","private_key_pem":"string","is_active":true};
const { body } = await request("${BASE_URL}/api/domains/hst456/dkim-keys", {
  method: "POST",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
      "Content-Type": "application/json",
  },
    body: JSON.stringify(bodyData),
});

console.log(await body.json());

import requests

payload = {"selector":"string","private_key_pem":"string","is_active":true}
response = requests.request( \
    "POST", \
    "${BASE_URL}/api/domains/hst456/dkim-keys", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = {"selector":"string","private_key_pem":"string","is_active":true}
with httpx.Client() as client:
    response = client.request( \
        "POST", \
        "${BASE_URL}/api/domains/hst456/dkim-keys", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := bytes.NewBuffer([]byte(`{"selector":"string","private_key_pem":"string","is_active":true}`))

req, err := http.NewRequest("POST", "${BASE_URL}/api/domains/hst456/dkim-keys", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = {"selector":"string","private_key_pem":"string","is_active":true}
uri = URI("${BASE_URL}/api/domains/hst456/dkim-keys")
request = Net::HTTP::Post.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
request.body = payload.to_json
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = {"selector":"string","private_key_pem":"string","is_active":true};
$client = new Client();
$response = $client->request("POST", "${BASE_URL}/api/domains/hst456/dkim-keys", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
  'json' => $payload,
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Post, "${BASE_URL}/api/domains/hst456/dkim-keys");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
request.Content = new StringContent("{\"selector\":\"string\",\"private_key_pem\":\"string\",\"is_active\":true}", Encoding.UTF8, "application/json");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

GET/api/domains/ask

Check if a domain is registered and eligible for TLS. Used by reverse proxies like Caddy to verify domain ownership before issuing certificates. More

Responses

204

Domain exists and is eligible for TLS

400application/problem+jsonValidationProblemDetails

Bad Request

schemaValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

404application/problem+jsonProblemDetails

Domain does not exist or is not eligible

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

defaultapplication/problem+jsonProblemDetails

HTTP Error

schemaProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

curl -X GET \\
  "${BASE_URL}/api/domains/ask?domain=string" \\
  -H "Authorization: Bearer ${API_TOKEN}"

const url = "${BASE_URL}/api/domains/ask?domain=string";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
});

console.log(await response.json());

const url = "${BASE_URL}/api/domains/ask?domain=string";
const response = await fetch(url, {
  method: "GET",
  headers: {
    "Authorization": "Bearer ${API_TOKEN}",
  },
} as RequestInit);

console.log(await response.json());

const response = await axios({
  method: "get",
  url: "${BASE_URL}/api/domains/ask?domain=string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

const response: AxiosResponse = await axios({
  method: "get",
  url: "${BASE_URL}/api/domains/ask?domain=string",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(response.data);

import { request } from "undici";

const { body } = await request("${BASE_URL}/api/domains/ask?domain=string", {
  method: "GET",
  headers: {
    Authorization: "Bearer ${API_TOKEN}",
  },
});

console.log(await body.json());

import requests

payload = None
response = requests.request( \
    "GET", \
    "${BASE_URL}/api/domains/ask?domain=string", \
    headers={"Authorization": "Bearer ${API_TOKEN}"}, \
    json=payload,
)
print(response.json())

import httpx

payload = None
with httpx.Client() as client:
    response = client.request( \
        "GET", \
        "${BASE_URL}/api/domains/ask?domain=string", \
        headers={"Authorization": "Bearer ${API_TOKEN}"}, \
        json=payload,
    )
print(response.json())

payload := http.NoBody

req, err := http.NewRequest("GET", "${BASE_URL}/api/domains/ask?domain=string", payload)
if err != nil {
  panic(err)
}
req.Header.Set("Authorization", "Bearer ${API_TOKEN}")
if payload != http.NoBody {
  req.Header.Set("Content-Type", "application/json")
}

res, err := (&http.Client{}).Do(req)
if err != nil {
  panic(err)
}
defer res.Body.Close()

require "json"
require "net/http"

payload = nil
uri = URI("${BASE_URL}/api/domains/ask?domain=string")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "Bearer ${API_TOKEN}"
request["Content-Type"] = "application/json"
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") { |http| \
  http.request(request) \
}
puts response.body

<?php

use GuzzleHttp\Client;

$payload = null;
$client = new Client();
$response = $client->request("GET", "${BASE_URL}/api/domains/ask?domain=string", [
  'headers' => [
    'Authorization' => 'Bearer ${API_TOKEN}',
  ],
]);

echo $response->getBody();

using System.Net.Http;
using System.Text;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "${BASE_URL}/api/domains/ask?domain=string");
request.Headers.Add("Authorization", "Bearer ${API_TOKEN}");
var response = await client.SendAsync(request);
Console.WriteLine(await response.Content.ReadAsStringAsync());

DkimKeyResponse

idstringrequired

Unique identifier for a DKIM key.

domain_idstringrequired

Unique identifier for a domain.

selectorstringrequired

The DKIM selector (s= tag)

is_activebooleanrequired

dns_record_namestringrequired

The DNS TXT record name (selector._domainkey.hostname)

dns_record_valuestringrequired

The DNS TXT record value to configure

created_atstringrequired

updated_atstringrequired

Domain

idstringrequired

Unique identifier for a domain.

account_idstringrequired

Unique identifier for an account.

hostnamestringrequired

The hostname

txt_verification_tokenstringrequired

Token for DNS TXT verification. Set this as a TXT record at _am.<hostname>

ProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

RfcEmailAddress

string

A valid, normalized RFC email address.

ValidationProblemDetails

typestring · urirequired

titlestringrequired

statusintegerrequired

detailstring

instancestring · uri

codestring

invalid_paramsarray

itemobjectrequired

instring

pathstring

typestring

expectedstring

receivedstring

Domains

Contents

List Account Domains

Create Account Domain

Search Account Domains

List Application Domains

Create Application Domain

Delete Application Domain

Get Application Domain

Patch Application Domain

List Mail Forwards

Create Mail Forward

Delete Mail Forward

Get Mail Forward

Patch Mail Forward

Delete DKIM Key

Get DKIM Key

Update DKIM Key

Delete Domain

Get Domain

Update Domain

Run Domain Checks

List DKIM Keys

Create DKIM Key

Check Domain

Models

Features

Types

Contents

Models

Related Features and Types

Features

Types