IntoDNS V1 API docs

Welcome to the IntoDNS API! This is a free API.

We have language bindings in Shell, PHP, Python, and JavaScript! You can view code examples in the dark area to the right, and you can switch the programming language of the examples with the tabs in the top right.

Usage limits and terms of use and disclaimer

This API is public and free to use, designed for access without requiring user identification. However, to maintain the service's stability and performance, there is a usage limit of 100 requests per minute. Any attempt to exceed this limit may result in temporary suspension of API access.

This API is provided "as is" and at your own risk. While every effort will be made to provide reliable data, accuracy, completeness, or timeliness of the data is not guaranteed. Users of this API agree that the provider shall not be liable for any direct or indirect damages resulting from the use of the API or the data obtained through it. This includes, but is not limited to, the reliability of the data for critical or sensitive applications, potential data loss, service interruptions, or any other harm arising from the use of the API.

By using this API, users agree to these terms and understand that the provider does not offer warranties nor assumes responsibility for the use of the data or any consequences that may arise from such use.

API Localization

The API supports Localization for some languages, all human text in API responses such as error messages are localized to suit the possible uses of this API.

To choose the language you have to send the header X-Accept-Language in any HTTP request. The available languages and their values are described in the following table

Language	Value
English	en
Spanish	es
French	fr
Portuguese	pt
German	de

Example of header for Portuguese language

X-Accept-Language: pt

Get DNS hosts request

curl -X GET 'https://intodns.io/api/v1/get-dns-hosts?host=raiolanetworks.com&wants-trace=1' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-hosts?host=raiolanetworks.com&wants-trace=1');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-hosts?host=raiolanetworks.com&wants-trace=1", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-hosts?host=raiolanetworks.com&wants-trace=1', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-hosts?host=raiolanetworks.com&wants-trace=1', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example:

{
    "trace": [
        {
            "host": "m.root-servers.net",
            "type": "HOST",
            "ipv4": "202.12.27.33",
            "ipv6": "2001:dc3::35",
            "operator": "WIDE Project"
        },
        {
            "host": "c.gtld-servers.net",
            "type": "HOST",
            "ipv4": "192.26.92.30",
            "ipv6": "2001:503:83eb::30",
            "status": 0,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": false,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": false
            },
            "warning-messages": [
                "The authoritative DNS does not have information about the domain"
            ]
        }
    ],
    "authority-hosts": [
        {
            "host": "ns-530.awsdns-02.net",
            "type": "HOST",
            "ipv4": "205.251.194.18",
            "ipv6": "2600:9000:5302:1200::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": []
        },
        {
            "host": "ns-474.awsdns-59.com",
            "type": "HOST",
            "ipv4": "205.251.193.218",
            "ipv6": "2600:9000:5301:da00::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": []
        },
        {
            "host": "ns-1222.awsdns-24.org",
            "type": "HOST",
            "ipv4": "205.251.196.198",
            "ipv6": "2600:9000:5304:c600::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": []
        },
        {
            "host": "ns-1916.awsdns-47.co.uk",
            "type": "HOST",
            "ipv4": "205.251.199.124",
            "ipv6": "2600:9000:5307:7c00::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": []
        }
    ]
}

This endpoint allows you to obtain information on the authoritative DNS hosts and all DNS hosts on the trace.

The authoritative DNS hosts are the DNS servers that contain the DNS zone information (all the information of the records of a domain name).

Also, you can get information of the DNS servers of the trace, this is the process of tracing DNS queries from the root servers to the authoritative servers to resolve a domain.

HTTP Request

GET https://intodns.io/api/v1/get-dns-hosts?host=<domain>&wants-trace=<1-0>

URL Parameters

Parameter	Type	Description
host *	`string`	Domain you want to consult.
wants-trace	`boolean`	Can have a values `0` (default) or `1`. Enable if you want to obtain information from the DNS hosts in the trace.

Response

Key	Type	Description
trace	`array<HOST>`	List of hosts (in order) of the process of tracing DNS queries from the root servers to the authoritative servers (not included).
authority-hosts	`array<HOST>`	List of authoritative servers.

HOST type

Key	Type	Description
host	`string`	Server name of host
type	`string`	Type identifier of host object.
ipv4	`string`	IPv4 of host.
ipv6	`string`	IPv6 of host.
operator	`string`	Server operator, only applies to the root servers.
status	`integer`	This is the status of the server evaluation. The values it can have are `1` (success), `0` (warning), `-1` (fail). Has more information in the field `warning-messages`.
flags	`object`	Key value object containing the boolean flags to define the host specific status.
flags.is-resolvable	`boolean`	Indicates that the server is responding correctly to DNS queries.
flags.has-ns-records	`boolean`	Indicates that the server has NS records for the domain queried.
flags.has-ns-records-in-authority-section	`boolean`	Indicates that the server has NS records on Authority section for the domain queried.
flags.has-soa-record	`boolean`	Indicates that the server has one SOA record for the domain queried.
warning-messages	`array`	Warning messages to complement the status of hosts.

Get DNS records request

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example, this is an example for NS type:

[
    {
        "host": "raiolanetworks.com",
        "type": "NS",
        "value": "ns-1222.awsdns-24.org",
        "ttl": 172800,
        "uuid": "6a37a4c7-8b62-46b4-82ec-74e004c57756",
        "ipv4": "205.251.196.198",
        "ipv6": "2600:9000:5304:c600::1"
    },
    {
        "host": "raiolanetworks.com",
        "type": "NS",
        "value": "ns-1916.awsdns-47.co.uk",
        "ttl": 172800,
        "uuid": "235f131b-f3da-4691-b086-0e958ae3773f",
        "ipv4": "205.251.199.124",
        "ipv6": "2600:9000:5307:7c00::1"
    }
]

This endpoint allows you to get the DNS records by type and you can use specific name server to make the request to a specific DNS server.

The structure of the response can change greatly depending on the type of records requested, each type has his own records data structure.

HTTP Request

GET https://intodns.io/api/v1/get-dns-records?host=<domain>&name-server=<resquested-name-server>&type=<type>

URL Parameters

Parameter	Type	Description
host *	`string`	Domain you want to consult.
name-server	`string`	Name server to make the request to a specific DNS server.
type *	`string`	DNS records type that you want to get.

The possible types are: NS, A, AAAA, CNAME, PTR, SOA, MX,TXT and CAA.

Get NS records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=NS', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for NS type:

[
    {
        "host": "raiolanetworks.com",
        "type": "NS",
        "value": "ns-1222.awsdns-24.org",
        "ttl": 172800,
        "uuid": "b4b84eee-0a46-4f7e-900c-9fd05b7c16f0",
        "ipv4": "205.251.196.198",
        "ipv6": "2600:9000:5304:c600::1"
    },
    {
        "host": "raiolanetworks.com",
        "type": "NS",
        "value": "ns-1916.awsdns-47.co.uk",
        "ttl": 172800,
        "uuid": "a696543c-566c-45d5-b2de-dbf880066d97",
        "ipv4": "205.251.199.124",
        "ipv6": "2600:9000:5307:7c00::1"
    }
]

This response return an array with NS records.

NS type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record.
ttl	`integer`	The time to live of record.
uuid	`string`	Unique identifier of record.
ipv4	`string`	IPv4 of host.
ipv6	`string`	IPv6 of host.

Get SOA records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=SOA' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=SOA');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=SOA", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=SOA', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=SOA', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for SOA type:

[
    {
        "host": "raiolanetworks.com",
        "type": "SOA",
        "ttl": 86400,
        "serial": 1,
        "refresh": 7200,
        "retry": 900,
        "expiry": 1209600,
        "mname": "ns-1222.awsdns-24.org.",
        "rname": "awsdns-hostmaster.amazon.com.",
        "minimum": 86400,
        "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
        "uuid": "5872560e-85c2-4a9c-a1c2-2a8d12848ca3"
    }
]

This response return an array with SOA records. There should only be one SOA registration.

SOA type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
ttl	`integer`	The time to live of record.
serial	`string` \| `integer`	Number that identifies a specific version of the DNS zone. A zone transfer maintains this value.
refresh	`integer`	Time that secondary DNS servers should wait before requesting changes from the primary DNS server.
retry	`integer`	Time that DNS servers should wait to request a zone update again after a previous failure.
expiry	`integer`	Time after which secondary servers that have not been able to update their zone stop responding to DNS queries.
mname	`string`	Primary DNS server of the DNS cluster and first source of DNS zone information.
rname	`string`	Contact email of the DNS zone administrator.
minimum	`integer`	Time to live (TTL) for negative cache responses.
value	`string`	The value of record.
uuid	`string`	Unique identifier of record.

Get A records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=A' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=A');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=A", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=A', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=A', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for A type:

[
    {
        "host": "raiolanetworks.com",
        "type": "A",
        "value": "201.46.113.251",
        "ttl": 86400,
        "uuid": "7366ee59-5cce-46e8-83b5-d15d78d1f249",
        "ip-host-name": "ip-201-46-113-251.ipinversa.es"
    }
]

This response return an array with A records.

A type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record. This is te IPv4 of the server to which the domain points.
ttl	`integer`	The time to live of record.
uuid	`string`	Unique identifier of record.
ip-host-name	`string`	This is the PTR of the IP of the field 'value'.

Get AAAA records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns2.google.com&type=AAAA' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns2.google.com&type=AAAA');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=google.com&name-server=ns2.google.com&type=AAAA", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns2.google.com&type=AAAA', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns2.google.com&type=AAAA', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for AAAA type:

[
    {
        "host": "google.com",
        "type": "AAAA",
        "value": "2a00:1450:4003:80f::200e",
        "ttl": 300,
        "ipbin": "*\u0000\u0014P@\u0003\b\u000f\u0000\u0000\u0000\u0000\u0000\u0000 \u000e",
        "uuid": "7f7c9538-a218-4bb4-9d53-eb0eb5545640",
        "ip-host-name": "mad41s14-in-x0e.1e100.net"
    }
]

This response return an array with AAAA records.

AAAA type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record. This is te IPv6 of the server to which the domain points.
ttl	`integer`	The time to live of record.
ipbin	`string`	The same value of IPv6 but in binary (parsed to string).
uuid	`string`	Unique identifier of record.
ip-host-name	`string`	This is the PTR of the IP of the field 'value'.

Get CNAME records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=www.raiolanetworks.com&name-server=ns-1916.awsdns-47.co.uk&type=CNAME' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=www.raiolanetworks.com&name-server=ns-1916.awsdns-47.co.uk&type=CNAME');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=www.raiolanetworks.com&name-server=ns-1916.awsdns-47.co.uk&type=CNAME", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=www.raiolanetworks.com&name-server=ns-1916.awsdns-47.co.uk&type=CNAME', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=www.raiolanetworks.com&name-server=ns-1916.awsdns-47.co.uk&type=CNAME', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for CNAME type:

[
    {
        "host": "www.raiolanetworks.com",
        "type": "CNAME",
        "value": "raiolanetworks.com",
        "ttl": 86400,
        "uuid": "cc12c463-11e2-4cb3-ad2f-d94191e6443e",
        "ipv4": "201.46.113.251",
        "ipv6": null
    }
]

This response return an array with CNAME records.

CNAME type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record.
ttl	`integer`	The time to live of record.
uuid	`string`	Unique identifier of record.
ipv4	`string`	IPv4 of host.
ipv6	`string`	IPv6 of host.

Get MX records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=MX' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=MX');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=MX", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=MX', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=MX', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for MX type:

[
    {
        "host": "raiolanetworks.com",
        "type": "MX",
        "value": "aspmx.l.google.com",
        "ttl": 86400,
        "level": 1,
        "uuid": "5786c7e5-c725-4660-b2b3-847e3f7fa815",
        "ipv4": "108.177.15.26",
        "ipv6": "2a00:1450:400c:c0c::1a"
    },
    {
        "host": "raiolanetworks.com",
        "type": "MX",
        "value": "alt1.aspmx.l.google.com",
        "ttl": 86400,
        "level": 5,
        "uuid": "5977df76-4713-452b-ba19-9bb2999c734b",
        "ipv4": "142.250.153.26",
        "ipv6": "2a00:1450:4013:c16::1a"
    }
]

This response return an array with MX records.

MX type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record.
ttl	`integer`	The time to live of record.
level	`integer`	The priority level of the record.
uuid	`string`	Unique identifier of record.
ipv4	`string`	IPv4 of host.
ipv6	`string`	IPv6 of host.

Get TXT records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=TXT' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=TXT');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=TXT", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=TXT', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=raiolanetworks.com&name-server=ns-1222.awsdns-24.org&type=TXT', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for TXT type:

[
    {
        "host": "raiolanetworks.com",
        "type": "TXT",
        "value": "ahrefs-site-verification_105b0a0c2c9516ee80425fbbdd52641bb249117dc593c78047eeca48747f5ddf",
        "ttl": 86400,
        "uuid": "9f521ed4-21c6-4c19-9796-2d1e33ca6663"
    },
    {
        "host": "raiolanetworks.com",
        "type": "TXT",
        "value": "facebook-domain-verification=ayb0ojfs7m8at84v8e96lfbdk1wkg8",
        "ttl": 86400,
        "uuid": "4e0a2854-1eb0-4709-8ec4-f65b056b043e"
    }
]

This response return an array with TXT records.

TXT type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record.
ttl	`integer`	The time to live of record.
uuid	`string`	Unique identifier of record.

Get CAA records

curl -X GET 'https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns1.google.com&type=CAA' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns1.google.com&type=CAA');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dns-records?host=google.com&name-server=ns1.google.com&type=CAA", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns1.google.com&type=CAA', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dns-records?host=google.com&name-server=ns1.google.com&type=CAA', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example for CAA type:

[
    {
        "host": "google.com",
        "type": "CAA",
        "value": "pki.goog",
        "ttl": 86400,
        "flags": 0,
        "tag": "issue",
        "uuid": "3f13d7cc-7b9c-4545-a43e-d454c282b842",
        "value-sentences": {
            "domain": "pki.goog"
        }
    }
]

This response return an array with CAA records.

CAA type

Key	Type	Description
host	`string`	Host name to which the record belongs.
type	`string`	Type identifier of host object.
value	`string`	The value of record.
ttl	`integer`	The time to live of record.
flags	`integer`	Field for future extensions, usually set to 0.
tag	`string`	Identifies the type of record and its purpose. This possible values are `issue`, `issuewild`, `iodef`.
uuid	`string`	Unique identifier of record.
value-sentences	`object`	It is the value field processed into its components, commonly containing only the domain but may include multiple additional parameters that will be classified here.

Get SPF record request

curl -X GET 'https://intodns.io/api/v1/get-spf-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-spf-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-spf-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com", headers={'X-Accept-Language': 'en'})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-spf-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-spf-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example:

{
    "uuid": "d4e34aeb-6a61-42a2-bcea-7fc60aa49290",
    "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
    "processed-correctly": true,
    "terms": {
        "authorise-own-a-records": true,
        "authorise-own-mx-records": true,
        "authorise-own-ptr": false,
        "a": [],
        "mx": [],
        "ptr": [],
        "exists": [],
        "ips": [
            {
                "qualifier": "+",
                "network": "178.32.28.33"
            }
        ],
        "exp": null,
        "redirect": null,
        "all": "-all",
        "includes": [
            {
                "qualifier": "+",
                "hostname": "mailgun.org"
            },
            {
                "qualifier": "+",
                "hostname": "_spf.google.com"
            },
            {
                "qualifier": "+",
                "hostname": "amazonses.com"
            }
        ]
    }
}

This endpoint allows you to get the SPF record that found among the TXT records (if exists).

HTTP Request

GET https://intodns.io/api/v1/get-spf-record?host=<domain>&name-server=<resquested-name-server>

URL Parameters

Parameter	Type	Description
host *	`string`	Domain you want to consult.
name-server	`string`	Name server to make the request to a specific DNS server.

SPF type

Key	Type	Description
uuid	`string`	Unique identifier of record.
record	`string`	This is the raw TXT record.
processed-correctly	`boolean`	This flag indicates that the record has been processed correcty, is possible that the records exists but has incorrect format and can't be parsed.
terms	`object`	Terms found in the record.
terms.authorise-own-a-records	`boolean`	Enables hosts present in the A records of the domain to send emails.
terms.authorise-own-mx-records	`boolean`	Enables hosts present in the MX records of the domain to send emails.
terms.authorise-own-ptr	`boolean`	Enables hosts present in the PTR records of the domain to send emails.
terms.a	`array`	List of the external domains that are enabled to send emails in their A records.
terms.mx	`array`	List of the external domains that are enabled to send emails in their MX records.
terms.ptr	`array`	List of the external domains that are enabled to send emails in their PTR records.
terms.exists	`array`	List of expressions that validate the format of the hostnames to which email sending is enabled.
terms.ips	`array`	List of IPs to which the sending of emails is enabled.
terms.exp	`string`	Sets the TXT record containing the response when the result is 'fail'.
terms.redirect	`string`	When no previous term validates, redirects the verification to the specified host. The query domain becomes the redirection domain when applied.
terms.all	`string`	This term indicates wich is the default action when another term does not validate. When present, 'redirect' is ignored.
terms.includes	`array`	List of additional SPF records from which this record will be extended.

Get DMARC record request

curl -X GET 'https://intodns.io/api/v1/get-dmarc-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com' \
  -H 'X-Accept-Language: en'

$handler = curl_init('https://intodns.io/api/v1/get-dmarc-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'X-Accept-Language: en',
]);

$output = json_decode(curl_exec($handler));

curl_close($handler);

var_dump($output);

import http.client
import json

conn = http.client.HTTPSConnection("intodns.io")

conn.request("GET", "/api/v1/get-dmarc-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com", headers={'X-Accept-Language': 'en'}
)

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

https.get('https://intodns.io/api/v1/get-dmarc-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com', {
  headers: {'X-Accept-Language': 'en'}
}, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
}).on('error', error => {console.error(error);});

// Browser

fetch('https://intodns.io/api/v1/get-dmarc-record?host=raiolanetworks.com&name-server=ns-474.awsdns-59.com', {
  headers: {'X-Accept-Language': 'en'}
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json response example:

{
    "uuid": "7e942c39-4540-45f8-949e-e298d1215438",
    "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
    "processed-correctly": true,
    "terms": {
        "p": "reject",
        "sp": "quarantine",
        "pct": "100",
        "rua": "mailto:dmarc@raiolanetworks.com",
        "ruf": "mailto:dmarc@raiolanetworks.com",
        "ri": "86400"
    }
}

This endpoint allows you to get the DMARC record that found among the TXT records of the subdomain _dmarc.yourdomain.com (if exists).

HTTP Request

GET https://intodns.io/api/v1/get-dmarc-record?host=<domain>&name-server=<resquested-name-server>

URL Parameters

Parameter	Type	Description
host *	`string`	Domain you want to consult.
name-server	`string`	Name server to make the request to a specific DNS server.

DMARC type

Key	Type	Description
uuid	`string`	Unique identifier of record.
record	`string`	This is the raw TXT record.
processed-correctly	`boolean`	This flag indicates that the record has been processed correcty, is possible that the records exists but has incorrect format and can't be parsed.
terms	`object`	Terms found in the record.
terms.p	`string`	Term that specifies the policy to follow when validation fails.
terms.sp	`string`	Equivalent to 'p', but applicable only to subdomains. If not present, 'p' applies.
terms.pct	`string`	Percentage of application of 'quarantine' or 'reject' policies.
terms.rua	`string`	URI or URIs to send aggregate validation activity reports to.
terms.ruf	`string`	URI or URIs to send forensic failure reports to.
terms.fo	`string`	Indicates the type of validation failure needed to generate a forensic report.
terms.aspf	`string`	Specifies the level of alignment required between the SPF and the From domain.
terms.adkim	`string`	Specifies the level of alignment required between the DKIM and the From domain.
terms.rf	`string`	Specifies the format used for the forensic reports sent.
terms.ri	`string`	Maximum interval of time between aggregate reports, required by recipient servers.

Run test request

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "<any-hostname>",
    "type" => "<any-type>",
    "test-name" => "<test-slug>",
    "test-params" => [
        "inspection-elements" => "<json>",
        "other-param" => "<any-value>"
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "<any-hostname>",
    "type": "<any-type>",
    "test-name": "<test-slug>",
    "test-params": {
        "inspection-elements": "<json>",
        "other-param": "<any-value>"
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "<any-hostname>",
  "type": "<any-type>",
  "test-name": "<test-slug>",
  "test-params": {
      "inspection-elements": "<json>",
      "other-param": "<any-value>"
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "<any-hostname>",
  "type": "<any-type>",
  "test-name": "<test-slug>",
  "test-params": {
      "inspection-elements": "<json>",
      "other-param": "<any-value>"
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "<any-hostname>",
    "type": "<any-type>",
    "test-name": "<test-slug>",
    "test-params": {
        "inspection-elements": "<json>",
        "other-param": "<any-value>"
    }
}

This endopoint allows you to run tests on the domain. There are many different tests with which you can check multiple things about the DNS context of a domain.

HTTP Request

POST https://intodns.io/api/v1/run-test

Parameters

Parameter	Type	Description
host *	`string`	Domain you want to consult.
target-hostname	`string`	Name server to make the request to a specific DNS server. Not all tests are queried on a specific name server.
type *	`string`	Category of test.
test-name *	`string`	The slug of the name of the test.
test-params	`object`	The specific test parameters (specified in each test).

Test categories: GENERAL, NS, TARGET_HOST, SOA, MX, TXT, CAA, SPF and DMARC.

Auto-recovery of test params

In many cases, tests will evaluate elements that are sent as parameters, these elements are usually DNS records that can be obtained previously with a Get DNS records request. These parameters are in most cases optional and will be indicated as such in the description of each test.

These optional inspection element parameters can be sent if desired to improve test performance, because in case they are not sent they will be automatically retrieved by making DNS requests to the target-hostname indicated in the request parameters, if the target-hostname is not specified either, then requests will be made to a DNS resolver such as 1.1.1.1 (Cloudflare resolver) or 8.8.8.8.8 (Google resolver).

Test response

Test response example:

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "NS",
            "value": "ns-1222.awsdns-24.org",
            "ttl": 172800,
            "uuid": "b7a76a68-0b8c-4472-b479-e736a213dc9b",
            "ipv4": "205.251.196.198",
            "ipv6": "2600:9000:5304:c600::1",
            "test-status": 1,
            "test-flags": {
                "has-any-resolvable-ip": true
            },
            "test-warning-messages": []
        },
        {
            "host": "raiolanetworks.com",
            "type": "NS",
            "value": "ns-1916.awsdns-47.co.uk",
            "ttl": 172800,
            "uuid": "b803e1fb-b048-4cdc-bd81-01c4c6b74966",
            "ipv4": "205.251.199.124",
            "ipv6": "2600:9000:5307:7c00::1",
            "test-status": 1,
            "test-flags": {
                "has-any-resolvable-ip": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "All records have a target that points to a host with at least one resolvable IP (IPv4 or IPv6)"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

All test responses has the same structure with this data:

Key	Type	Description
test-status	`integer`	Global test status, generally can be four values: `1` (Success), `0` (Warning), `-1` (Fail) and `5` (Not applicable). Not all tests have all cases. In the description of each test defines the cases and their significance.
output-elements	`array` \| `object`	Here usually come back the elements sent in the parameters after being evaluated. Depending on the test, more than one type of element may arrive, in this type of test this key comes as an object with the different sets of elements. The peculiarities are specified in each test. These elements will be the same objects that have been sent in the test parameters but will contain new keys such as `test-status` or `test-flags`, these keys are defined as follows.
output-elements.test-status	`integer`	It's the same that the global `test-status` but applied to each output element.
output-elements.test-flags	`object`	It's a key - value object with the test flags. These are the items that are checked in each test for each element. This indicates the specific status of each element in the test.
output-elements.test-warning-messages	`array`	Specific warning messages for each output element.
test-successful-messages	`array`	Global successful messages.
test-warning-messages	`array`	Global warning messages.
test-info-messages	`array`	Global information messages, usually are complementary information.

General tests

Type: GENERAL

These tests are not aimed at checking a specific type of record, some are global DNS configuration tests that cannot be classified into specific test types.

Authority hosts are equivalent to NS records test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "GENERAL",
    "test-name" => "authority-hosts-are-equivalent-to-ns-records",
    "test-params" => [
        "authority-hosts" => [
          // Optional authority hosts objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "GENERAL",
    "test-name": "authority-hosts-are-equivalent-to-ns-records",
    "test-params": {
        "authority-hosts": [
          # Optional authority hosts objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "GENERAL",
  "test-name": "authority-hosts-are-equivalent-to-ns-records",
  "test-params": {
      "authority-hosts": [
        // Optional authority hosts objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "GENERAL",
  "test-name": "authority-hosts-are-equivalent-to-ns-records",
  "test-params": {
      "authority-hosts": [
        // Optional authority hosts objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "GENERAL",
    "test-name": "authority-hosts-are-equivalent-to-ns-records",
    "test-params": {
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": {
        "ns": [
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-474.awsdns-59.com",
                "ttl": 172800,
                "uuid": "d1e04b69-ca93-40e4-a2a7-cb11c605b6a4",
                "test-status": 1,
                "test-flags": {
                    "ns-record-points-to-authority-hosts-correctly": true
                },
                "test-warning-messages": []
            },
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-530.awsdns-02.net",
                "ttl": 172800,
                "uuid": "a5528f7b-00f5-4393-a699-ed3c86264eb9",
                "test-status": 1,
                "test-flags": {
                    "ns-record-points-to-authority-hosts-correctly": true
                },
                "test-warning-messages": []
            }
        ],
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "authority-host-is-referenced-by-ns-record": true
                },
                "test-warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "authority-host-is-referenced-by-ns-record": true
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "The NS records are equivalent to the authoritative DNS servers"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: authority-hosts-are-equivalent-to-ns-records

Description

This tests checks that the NS records are equivalent to authority hosts. A correct configuration has the NS registers equivalent to the authority hosts.

You can send the parameterauthority-hosts optionally.

Test parameters

Parameter	Type	Mandatory	Description
authority-hosts	`array<HOST>`	No	Authority hosts of domain.

The parameter "authority-hosts" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the HOST type to see the type of data that can be sent.

Cases

Case	Status	Description
Success	`1`	All NS records and authority hosts are equivalents.
Fail	`-1`	Some NS record or authority hosts are't equivalent to other element.

Output element test flags for NS records

Key	Description
ns-record-points-to-authority-hosts-correctly	The NS records points to some authority hosts.

Output element test flags for authority hosts

Key	Description
authority-host-is-referenced-by-ns-record	The host is refered by some NS record.

All authority hosts has the same SOA test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "GENERAL",
    "test-name" => "all-authority-hosts-has-same-soa",
    "test-params" => [
        "mode" => "auto"
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "GENERAL",
    "test-name": "all-authority-hosts-has-same-soa",
    "test-params": {
        "mode": "auto"
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "GENERAL",
  "test-name": "all-authority-hosts-has-same-soa",
  "test-params": {
      "mode": "auto"
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "GENERAL",
  "test-name": "all-authority-hosts-has-same-soa",
  "test-params": {
      "mode": "auto"
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters for Auto mode:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "GENERAL",
    "test-name": "all-authority-hosts-has-same-soa",
    "test-params": {
        "mode": "auto"
    }
}

Response for Auto mode example:

{
    "test-status": 1,
    "output-elements": {
        "soa-record-sample": {
            "hostname": "ns-530.awsdns-02.net",
            "record": {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400"
            }
        },
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "soa-record-is-equal-to-the-sample": true
                },
                "test-warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "soa-record-is-equal-to-the-sample": true
                },
                "test-warning-messages": []
            }
        ],
        "ns": [
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1222.awsdns-24.org",
                "ttl": 172800,
                "uuid": "bfa65aaf-2c9b-4a06-a811-f84781f9bb61",
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "soa-record-is-equal-to-the-sample": true
                },
                "test-warning-messages": []
            },
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1916.awsdns-47.co.uk",
                "ttl": 172800,
                "uuid": "6648e7f9-758d-4155-9ea0-c64882eec55b",
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "soa-record-is-equal-to-the-sample": true
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "All authoritative DNS servers have an SOA record equal to the reference"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The SOA record used as reference is that of the authoritative DNS ns-530.awsdns-02.net"
    ]
}

Json parameters for Authority hosts mode:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "GENERAL",
    "test-name": "all-authority-hosts-has-same-soa",
    "test-params": {
        "mode": "authority-hosts",
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            }
        ]
    }
}

Response for Authority hosts mode example:

{
    "test-status": 1,
    "output-elements": {
        "soa-record-sample": {
            "hostname": "ns-530.awsdns-02.net",
            "record": {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400"
            }
        },
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "soa-record-is-equal-to-the-sample": true
                },
                "test-warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "soa-record-is-equal-to-the-sample": true
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "All authoritative DNS servers have an SOA record equal to the reference"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The SOA record used as reference is that of the authoritative DNS ns-530.awsdns-02.net"
    ]
}

Json parameters for Extra NS mode:

{
    "host": "rn-com.in-test.dev",
    "target-hostname": "dns1.raiolanetworks.es",
    "type": "GENERAL",
    "test-name": "all-authority-hosts-has-same-soa",
    "test-params": {
        "mode": "with-extra-ns",
        "output-only-for-ns": true,
        "authority-hosts": [
            {
                "host": "dns10.webcloud.es",
                "type": "HOST",
                "ipv4": null,
                "ipv6": null,
                "status": -1,
                "flags": {
                    "is-resolvable": false,
                    "has-ns-records": false,
                    "has-ns-records-in-authority-section": false,
                    "has-soa-record": false
                },
                "warning-messages": [
                    "The authoritative DNS is unable to resolve DNS requests"
                ]
            },
            {
                "host": "dns2.raiolanetworks.es",
                "type": "HOST",
                "ipv4": "52.17.24.175",
                "ipv6": "2a05:d018:1f0c:ca00:c4b3:a34f:88c:9245",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            }
        ],
        "records": [
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns20.webcloud.es",
                "ttl": 86400,
                "uuid": "d8ddc0bf-60bc-4404-9ce6-c96b1abf7f11",
                "ipv4": null,
                "ipv6": null
            },
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns2.webcloud.es",
                "ttl": 86400,
                "uuid": "3175deac-fb70-415c-b8f0-842bf5b17b98",
                "ipv4": "151.80.177.210",
                "ipv6": null
            }
        ]
    }
}

Response for Extra NS mode example:

{
    "test-status": -1,
    "output-elements": {
        "soa-record-sample": {
            "hostname": "dns1.raiolanetworks.es",
            "record": {
                "host": "rn-com.in-test.dev",
                "type": "SOA",
                "serial": 2024060301,
                "refresh": 60,
                "retry": 60,
                "expiry": 60,
                "mname": "dns1.raiolanetworks.es.",
                "rname": "cpanel.raiolanetworks.es.",
                "minimum": 5,
                "value": "dns1.raiolanetworks.es. cpanel.raiolanetworks.es. 2024060301 60 60 60 5"
            }
        },
        "ns": [
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns20.webcloud.es",
                "ttl": 86400,
                "uuid": "d8ddc0bf-60bc-4404-9ce6-c96b1abf7f11",
                "ipv4": null,
                "ipv6": null,
                "test-status": -1,
                "test-flags": {
                    "is-resolvable": false,
                    "has-soa-record": false,
                    "soa-record-is-equal-to-the-sample": false
                },
                "test-warning-messages": [
                    "The authoritative DNS is unable to resolve DNS requests"
                ]
            },
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns2.webcloud.es",
                "ttl": 86400,
                "uuid": "3175deac-fb70-415c-b8f0-842bf5b17b98",
                "ipv4": "151.80.177.210",
                "ipv6": null,
                "test-status": -1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": false,
                    "soa-record-is-equal-to-the-sample": false
                },
                "test-warning-messages": [
                    "The authoritative DNS does not have an SOA record for the domain"
                ]
            }
        ]
    },
    "test-successful-messages": [],
    "test-warning-messages": [
        "The authoritative DNS dns20.webcloud.es cannot be resolved",
        "The authoritative DNS dns2.webcloud.es does not have an SOA record"
    ],
    "test-info-messages": [
        "It is checked that the servers declared in the NS records that were not found as authoritative DNS servers have the same SOA record as the rest of the authoritative DNS servers",
        "The SOA record used as reference is that of the authoritative DNS dns1.raiolanetworks...."
    ]
}

Slug: all-authority-hosts-has-same-soa

Description

This test checks that the authority hosts has the same SOA record. In order for the zone information to be propagated correctly among all DNS servers hosting the zone, they must contain the same SOA record.

This is done by taking a SOA record sample from a random authority host and comparing it to the SOA records of the rest hosts.

Occasionally there may be NS records that have not been found as authority hosts and you may need to checks the DNS servers that are targeted by extra NS that have not been found as authority hosts by the trace.

This test has three modes: auto, authority-hosts and with-extra-ns.

The auto mode not need parameters, it recovery automatically all authority hosts and NS records of domain an compare his SOA records.
The authority-hosts mode is only for checks the authority hosts, not the NS records. In this mode you can send the parameter authority-hosts to improve the performance, but if you don't send the authority-hosts parameter then it will be recovery automatically. This mode compare the SOA records only for authority hosts.
The with-extra-ns mode has the same behaviour as the authority-hosts mode but can send a records parameter with extra NS records to checks them together with the authority hosts. This allows you to send only some specific NS records and not all NS and authority hosts as in auto mode.

Test parameters

Parameter	Type	Mandatory	Description
mode	`string`	No	The mode of the test, It can has three values, `auto`, `authority-hosts` and `with-extra-ns`, by default work with `auto` mode.
authority-hosts	`array<HOST>`	No	Authority hosts of domain.
records	`array<NS>`	No	Some specific NS records of domain. This parameter is mandatory in `with-extra-ns` mode.
output-only-for-ns	`boolean`	No	In the modes `auto` and `with-extra-ns` if this flag is enabled, only `ns` records will be received in the `output-elements`, `authority-hosts` shall not be added to the output. Although authority hosts are compared internally in the tests, they will not be added to the output in order to have more cleanliness and to avoid adding unnecessary data in case authority hosts are not evaluated.

The parameter "authority-hosts" aren't mandatory in any mode, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

The parameter "records" are mandatory in the mode with-extra-ns.

See the HOST type to see the type of data that can be sent.

See the NS type to see the type of data that can be sent.

Cases

Case	Status	Description
Success	`1`	All inspected elements (NS or authority hosts) has the same SOA record.
Fail	`-1`	Some inspected element (NS or authority hosts) has different SOA record.

Output element test flags for Authority hosts and NS records

Key	Description
is-resolvable	If affirmative, this flag indicates that the DNS host to which the element points can resolve DNS requests.
has-soa-record	If affirmative, this flag indicates that the DNS host to which the element points has SOA record for the domain.
soa-record-is-equal-to-the-sample	If affirmative, this flag indicates that the SOA record is equal as the SOA sample.

AXFR request does not resolve on any DNS server test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "GENERAL",
    "test-name" => "axfr-does-not-resolve-on-any-dns-server",
    "test-params" => [
        "mode" => "auto"
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "GENERAL",
    "test-name": "axfr-does-not-resolve-on-any-dns-server",
    "test-params": {
        "mode": "auto"
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "GENERAL",
  "test-name": "axfr-does-not-resolve-on-any-dns-server",
  "test-params": {
      "mode": "auto"
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "GENERAL",
  "test-name": "axfr-does-not-resolve-on-any-dns-server",
  "test-params": {
      "mode": "auto"
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters for Auto mode:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "GENERAL",
    "test-name": "axfr-does-not-resolve-on-any-dns-server",
    "test-params": {
        "mode": "auto"
    }
}

Response for Auto mode example:

{
    "test-status": 1,
    "output-elements": {
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": []
            }
        ],
        "ns": [
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1222.awsdns-24.org",
                "ttl": 172800,
                "uuid": "3649da6d-4d53-4ce0-b554-4b83249d8217",
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": []
            },
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1916.awsdns-47.co.uk",
                "ttl": 172800,
                "uuid": "b314ce59-2e05-4cc6-9ddd-197eda1cbbb0",
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": []
            },
        ]
    },
    "test-successful-messages": [
        "No DNS server allows DNS zone transfer"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Json parameters for Authority hosts mode:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "GENERAL",
    "test-name": "axfr-does-not-resolve-on-any-dns-server",
    "test-params": {
        "mode": "authority-hosts",
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            }
        ]
    }
}

Response for Authority hosts mode example:

{
    "test-status": 1,
    "output-elements": {
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": [],
                "test-status": 1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": true,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "No DNS server allows DNS zone transfer"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Json parameters for Extra NS mode:

{
    "host": "rn-com.in-test.dev",
    "target-hostname": "dns3.raiolanetworks.es",
    "type": "GENERAL",
    "test-name": "axfr-does-not-resolve-on-any-dns-server",
    "test-params": {
        "mode": "ns",
        "records": [
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns2.webcloud.es",
                "ttl": 86400,
                "uuid": "12a1fb3a-15a0-42ba-8cb2-cfcf50e3dee6",
                "ipv4": "151.80.177.210",
                "ipv6": null
            },
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns20.webcloud.es",
                "ttl": 86400,
                "uuid": "06b47f39-9b61-4267-87d5-163053d1546c",
                "ipv4": null,
                "ipv6": null
            }
        ]
    }
}

Response for Extra NS mode example:

{
    "test-status": -1,
    "output-elements": {
        "ns": [
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns2.webcloud.es",
                "ttl": 86400,
                "uuid": "12a1fb3a-15a0-42ba-8cb2-cfcf50e3dee6",
                "ipv4": "151.80.177.210",
                "ipv6": null,
                "test-status": -1,
                "test-flags": {
                    "is-resolvable": true,
                    "has-soa-record": false,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": [
                    "The authoritative DNS does not have an SOA record for the domain"
                ]
            },
            {
                "host": "rn-com.in-test.dev",
                "type": "NS",
                "value": "dns20.webcloud.es",
                "ttl": 86400,
                "uuid": "06b47f39-9b61-4267-87d5-163053d1546c",
                "ipv4": null,
                "ipv6": null,
                "test-status": -1,
                "test-flags": {
                    "is-resolvable": false,
                    "has-soa-record": false,
                    "allows-zone-transfer-with-a-axfr-request": false
                },
                "test-warning-messages": [
                    "The authoritative DNS is unable to resolve DNS requests"
                ]
            }
        ]
    },
    "test-successful-messages": [],
    "test-warning-messages": [
        "The NS record dns2.webcloud.es does not have information about the domain",
        "The NS record dns20.webcloud.es is unable to resolve DNS requests"
    ],
    "test-info-messages": []
}

Slug: axfr-does-not-resolve-on-any-dns-server

Description

This test checks that the authority hosts not resolve a zone transfer query, in other words, not resolves a query of type AXFR. The query of type AXFR is used among authority hosts servers to update the zone information of the domain name. If this request can be resolved publicly, it represents a serious security breach.

The test iterates the inspection elements (authority hosts or NS records) making an AXFR request for each. Checks that no DNS servers to which the inspection elements point resolve the AXFR request.

Before making each AXFR request, the DNS server is checked for domain zone information by means of a SOA request, this is done to avoid making AXFR requests to servers that do not have domain name zone information.

Occasionally there may be NS records that have not been found as authority hosts and you may need to check the DNS servers that are targeted by extra NS that have not been found as authority hosts by the trace.

This test has three modes: auto, authority-hosts and ns.

The auto mode not need parameters, it recovery automatically all authority hosts and NS records of domain and checks that no DNS servers resolve AXFR requests.
The authority-hosts mode is only for check the authority hosts, not the NS records. In this mode you can send the parameter authority-hosts to improve the performance, but if you don't send the authority-hosts parameter then it will be recovery automatically. This mode checks that no DNS servers to which the authority hosts point resolve AXFR requests.
The ns mode has the same behaviour as the authority-hosts mode but with records parameter instead of authority-hosts parameter, you can send the specific NS records in the records parameter or not send any NS records and it will be recovery automatically. This mode checks that no DNS servers to which the NS records point resolve AXFR requests.

Test parameters

Parameter	Type	Mandatory	Description
mode	`string`	No	The mode of the test, It can has three values, `auto`, `authority-hosts` and `ns`, by default work with `auto` mode.
authority-hosts	`array<HOST>`	No	Authority hosts of domain.
records	`array<NS>`	No	Some specific NS records of domain or all NS records.

The parameter "authority-hosts" and "records" aren't mandatory in any mode, this parameters are a auto-recovery params, you can see the section of Auto-recovery of test params.

See the HOST type to see the type of data that can be sent.

See the NS type to see the type of data that can be sent.

Cases

Case	Status	Description
Success	`1`	All inspected elements (NS or authority hosts) are resolvables, have zone information (has SOA record) and can't transfer the zone by a AXFR query.
Fail	`-1`	Some inspected element (NS or authority hosts) aren't resolvable or haven't zone information (hasn't SOA record) or can transfer the zone by AXFR query.

Output element test flags for Authority hosts and NS records

Key	Description
is-resolvable	If affirmative, this flag indicates that the DNS host to which the element points can resolve DNS requests.
has-soa-record	If affirmative, this flag indicates that the DNS host to which the element points has SOA record for the domain.
allows-zone-transfer-with-a-axfr-request	If affirmative, this flag indicates that the DNS host to which the element points can transfer the zone information publicly (this is the worst case).

Recommended number of authority hosts test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "GENERAL",
    "test-name" => "recommended-number-of-authority-hosts",
    "test-params" => [
        "authority-hosts" => [
          // Optional authority hosts objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "GENERAL",
    "test-name": "recommended-number-of-authority-hosts",
    "test-params": {
        "authority-hosts": [
          # Optional authority hosts objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "GENERAL",
  "test-name": "recommended-number-of-authority-hosts",
  "test-params": {
      "authority-hosts": [
        // Optional authority hosts objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "GENERAL",
  "test-name": "recommended-number-of-authority-hosts",
  "test-params": {
      "authority-hosts": [
        // Optional authority hosts objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "GENERAL",
    "test-name": "recommended-number-of-authority-hosts",
    "test-params": {
        "authority-hosts": [
            {
                "host": "ns-530.awsdns-02.net",
                "type": "HOST",
                "ipv4": "205.251.194.18",
                "ipv6": "2600:9000:5302:1200::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-1222.awsdns-24.org",
                "type": "HOST",
                "ipv4": "205.251.196.198",
                "ipv6": "2600:9000:5304:c600::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-1916.awsdns-47.co.uk",
                "type": "HOST",
                "ipv4": "205.251.199.124",
                "ipv6": "2600:9000:5307:7c00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "ns-530.awsdns-02.net",
            "type": "HOST",
            "ipv4": "205.251.194.18",
            "ipv6": "2600:9000:5302:1200::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": [],
            "test-status": 1,
            "test-flags": [],
            "test-warning-messages": []
        },
        {
            "host": "ns-474.awsdns-59.com",
            "type": "HOST",
            "ipv4": "205.251.193.218",
            "ipv6": "2600:9000:5301:da00::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": [],
            "test-status": 1,
            "test-flags": [],
            "test-warning-messages": []
        },
        {
            "host": "ns-1222.awsdns-24.org",
            "type": "HOST",
            "ipv4": "205.251.196.198",
            "ipv6": "2600:9000:5304:c600::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": [],
            "test-status": 1,
            "test-flags": [],
            "test-warning-messages": []
        },
        {
            "host": "ns-1916.awsdns-47.co.uk",
            "type": "HOST",
            "ipv4": "205.251.199.124",
            "ipv6": "2600:9000:5307:7c00::1",
            "status": 1,
            "flags": {
                "is-resolvable": true,
                "has-ns-records": true,
                "has-ns-records-in-authority-section": true,
                "has-soa-record": true
            },
            "warning-messages": [],
            "test-status": 1,
            "test-flags": [],
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The number of authoritative DNS servers is 4. It is within the optimal range (2 < x \u2264 7)"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: recommended-number-of-authority-hosts

Description

This test checks the number of authority hosts, it is recommended to have at least 2 and optimally between 3 and 7.

The optimal range is (2 < x ≤ 7) authority hosts. If it has only 2 authority hosts isn't optimal but not a bad configuration either.

Test parameters

Parameter	Type	Mandatory	Description
authority-hosts	`array<HOST>`	No	Authority hosts of domain.

The parameter "authority-hosts" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the HOST type to see the type of data that can be sent.

Cases

Case	Status	Description
Success	`1`	The number of authority hosts is in the optimal range (2 < x ≤ 7).
warning	`0`	The number of authority hosts is the minimal recommendable configuration with 2 hosts.
Fail	`-1`	The number of authority hosts isn't 2 and furthermore is out of the optimal range (2 < x ≤ 7).

Output element test flags

This test hasn't element test flags.

DNSSEC check

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "GENERAL",
    "test-name" => "dnssec-check",
    "test-params" => []
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "GENERAL",
    "test-name": "dnssec-check",
    "test-params": {}
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "GENERAL",
  "test-name": "dnssec-check",
  "test-params": {}
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "GENERAL",
  "test-name": "dnssec-check",
  "test-params": {}
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "GENERAL",
    "test-name": "dnssec-check",
    "test-params": {}
}

Response

{
    "test-status": -1,
    "output-elements": [],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The domain does not have DNSSEC configured, preventing the authenticity of the domain's DNS information from being verified"
    ],
    "test-info-messages": [
        "This information is provided by DNSViz (https:\/\/github.com\/dnsviz\/dnsviz)"
    ]
}

Slug: dnssec-check

Description

This test checks that the domain has a complete DNSSEC protection. DNSSEC (Domain Name System Security Extensions) adds a layer of security to the DNS, authenticating responses and ensuring data integrity to prevent attacks such as cache poisoning and man in the middle attacks.

This test uses the DNSViz tool: Go to the GitHub project

Test parameters

This test hasn't test parameters.

Cases

Case	Status	Description
Not aplicable	`5`	Unexcepted error when run the DNSSEC analysis.
Success	`1`	The domain has DNSSEC correctly configured, allowing the authenticity of the domain's DNS information to be verified.
warning	`0`	The DNSSEC configuration of the domain cannot be completely verified due to other DNS configuration issues with the domain.
Fail	`-1`	The domain does not have DNSSEC configured, preventing the authenticity of the domain's DNS information from being verified. Or the DNSSEC configuration of the domain is incorrect, which may be due to a configuration error, the use of expired or forged signatures, or a temporary error. The different fail cases are specified in the `warning-messages` of the test response.

Output element test flags

This test hasn't element test flags.

NS tests

Type: NS

This section describes the tests of the NS records.

Target hosts with resolvable IPs test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "NS",
    "test-name" => "target-hosts-with-resolvable-ips",
    "test-params" => [
        "records" => [
          // Optional NS records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "NS",
    "test-name": "target-hosts-with-resolvable-ips",
    "test-params": {
        "records": [
          # Optional NS records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "NS",
  "test-name": "target-hosts-with-resolvable-ips",
  "test-params": {
      "records": [
        // Optional NS records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "NS",
  "test-name": "target-hosts-with-resolvable-ips",
  "test-params": {
      "records": [
        // Optional NS records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "NS",
    "test-name": "target-hosts-with-resolvable-ips",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1222.awsdns-24.org",
                "ttl": 172800,
                "uuid": "b7a76a68-0b8c-4472-b479-e736a213dc9b",
                "ipv4": "205.251.196.198",
                "ipv6": "2600:9000:5304:c600::1"
            },
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1916.awsdns-47.co.uk",
                "ttl": 172800,
                "uuid": "b803e1fb-b048-4cdc-bd81-01c4c6b74966",
                "ipv4": "205.251.199.124",
                "ipv6": "2600:9000:5307:7c00::1"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "NS",
            "value": "ns-1222.awsdns-24.org",
            "ttl": 172800,
            "uuid": "37789ac6-ee89-47d2-a2c3-28fa4e4bbfe6",
            "ipv4": "205.251.196.198",
            "ipv6": "2600:9000:5304:c600::1",
            "test-status": 1,
            "test-flags": {
                "has-any-resolvable-ip": true
            },
            "test-warning-messages": []
        },
        {
            "host": "raiolanetworks.com",
            "type": "NS",
            "value": "ns-1916.awsdns-47.co.uk",
            "ttl": 172800,
            "uuid": "fab69739-844b-4cd5-bb2e-e6a4dcf72930",
            "ipv4": "205.251.199.124",
            "ipv6": "2600:9000:5307:7c00::1",
            "test-status": 1,
            "test-flags": {
                "has-any-resolvable-ip": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "All records have a target that points to a host with at least one resolvable IP (IPv4 or IPv6)"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: target-hosts-with-resolvable-ips

Description

This test check that the hosts to which the records point have resolvable ips, at least one IP (IPv4 or IPv6).

Test parameters

Parameter	Type	Mandatory	Description
records	`array<NS>`	No	NS records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the NS type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has hosts with resolvable IPs.
Fail	`-1`	Some records has hosts with irresolvable IPs.

Output element test flags

Key	Description
has-any-resolvable-ip	If affirmative, this flag indicates that the analysed record has at least one resolvable IP.

Record has recommended TTL range test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "NS",
    "test-name" => "records-has-recommended-ttl-range",
    "test-params" => [
        "records" => [
          // Optional NS records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "NS",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
          # Optional NS records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "NS",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional NS records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "NS",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional NS records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "NS",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1222.awsdns-24.org",
                "ttl": 172800,
                "uuid": "b7a76a68-0b8c-4472-b479-e736a213dc9b",
                "ipv4": "205.251.196.198",
                "ipv6": "2600:9000:5304:c600::1"
            },
            {
                "host": "raiolanetworks.com",
                "type": "NS",
                "value": "ns-1916.awsdns-47.co.uk",
                "ttl": 172800,
                "uuid": "b803e1fb-b048-4cdc-bd81-01c4c6b74966",
                "ipv4": "205.251.199.124",
                "ipv6": "2600:9000:5307:7c00::1"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "NS",
            "value": "ns-1222.awsdns-24.org",
            "ttl": 172800,
            "uuid": "37789ac6-ee89-47d2-a2c3-28fa4e4bbfe6",
            "ipv4": "205.251.196.198",
            "ipv6": "2600:9000:5304:c600::1",
            "test-status": 1,
            "test-flags": {
                "has-recommended-ttl": true
            },
            "test-warning-messages": []
        },
        {
            "host": "raiolanetworks.com",
            "type": "NS",
            "value": "ns-1916.awsdns-47.co.uk",
            "ttl": 172800,
            "uuid": "fab69739-844b-4cd5-bb2e-e6a4dcf72930",
            "ipv4": "205.251.199.124",
            "ipv6": "2600:9000:5307:7c00::1",
            "test-status": 1,
            "test-flags": {
                "has-recommended-ttl": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "All records have an optimal TTL according to their type"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The optimal TTL range for the NS records is ( 86400 \u2264  x \u2264 \u221e )"
    ]
}

Slug: records-has-recommended-ttl-range

Description

This test check that the records TTL (time to live) is between a optimal range. Some records types has two ranges, the optimal range and recommended range. If a record TTL is in the optimal range then is evaluated with status 1 (Success), if a record TTL is in the recommended range is evaluated with status 0 (Warning), but if is out the recommended range then is evaluated with status -1 (Fail).

The NS records optimal range is ( 86400 ≤ x ≤ ∞ ), meaning between 24 hours and infinite.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<NS>`	No	NS records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the NS type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has optimal TTL.
Warning	`0`	Some records has optimal TTL, an others has recommended TTL but none is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).
Fail	`-1`	Some records is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).

Output element test flags

Key	Description
has-recommended-ttl	If affirmative, this flag indicates that the analysed record has a optimal or recommended TTL.

SOA tests

Type: SOA

This section describes the tests of the SOA record.

The term mname is real authority hosts test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "SOA",
    "test-name" => "mname-term-is-real-authority-host",
    "test-params" => [
        "records" => [
          // Optional SOA record object
        ],
        "authority-hosts" => [
            // Optional authority hosts objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "SOA",
    "test-name": "mname-term-is-real-authority-host",
    "test-params": {
        "records": [
          # Optional SOA record object
        ],
        "authority-hosts": [
          # Optional authority hosts objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "SOA",
  "test-name": "mname-term-is-real-authority-host",
  "test-params": {
      "records": [
        // Optional SOA record object
      ],
      "authority-hosts": [
        // Optional authority hosts objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "SOA",
  "test-name": "mname-term-is-real-authority-host",
  "test-params": {
      "records": [
        // Optional SOA record object
      ],
      "authority-hosts": [
        // Optional authority hosts objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "SOA",
    "test-name": "mname-term-is-real-authority-host",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "ttl": 86400,
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
                "uuid": "6ab1d882-4531-4c18-865f-d67d63c49eea"
            }
        ],
        "authority-hosts": [
            {
                "host": "ns-474.awsdns-59.com",
                "type": "HOST",
                "ipv4": "205.251.193.218",
                "ipv6": "2600:9000:5301:da00::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            },
            {
                "host": "ns-1222.awsdns-24.org",
                "type": "HOST",
                "ipv4": "205.251.196.198",
                "ipv6": "2600:9000:5304:c600::1",
                "status": 1,
                "flags": {
                    "is-resolvable": true,
                    "has-ns-records": true,
                    "has-ns-records-in-authority-section": true,
                    "has-soa-record": true
                },
                "warning-messages": []
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "SOA",
            "ttl": 86400,
            "serial": 1,
            "refresh": 7200,
            "retry": 900,
            "expiry": 1209600,
            "mname": "ns-1222.awsdns-24.org.",
            "rname": "awsdns-hostmaster.amazon.com.",
            "minimum": 86400,
            "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
            "uuid": "6ab1d882-4531-4c18-865f-d67d63c49eea",
            "test-status": 1,
            "test-flags": {
                "mname-term-is-real-authority-host": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The mname term is one of the authoritative DNS"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: mname-term-is-real-authority-host

Description

This test check that the term mname of the SOA record points to a real authority hosts of domain.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SOA>`	No	SOA records of domain. Only should send one record.
authority-hosts	`array<HOST>`	No	Authority hosts of domain.

The parameters "records" and "authority-hosts" aren't mandatory, this parameters are a auto-recovery params, you can see the section of Auto-recovery of test params.

See the SOA type to see the type of records that can be sent.

See the HOST type to see the type of authority-hosts that can be sent.

Cases

Case	Status	Description
Success	`1`	The mname term points to real authority host.
Fail	`-1`	The mname term not points to real authority host.

Output element test flags

Key	Description
mname-term-is-real-authority-host	If affirmative, this flag indicates that the mname term points to real authority host of this domain.

Serial term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "SOA",
    "test-name" => "serial-term",
    "test-params" => [
        "records" => [
          // Optional SOA record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SOA",
    "test-name": "serial-term",
    "test-params": {
        "records": [
          # Optional SOA record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SOA",
  "test-name": "serial-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SOA",
  "test-name": "serial-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SOA",
    "test-name": "serial-term",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "ttl": 86400,
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
                "uuid": "5c6b31fc-885c-4bdb-9b6b-2c2edf28294a"
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "SOA",
            "ttl": 86400,
            "serial": 1,
            "refresh": 7200,
            "retry": 900,
            "expiry": 1209600,
            "mname": "ns-1222.awsdns-24.org.",
            "rname": "awsdns-hostmaster.amazon.com.",
            "minimum": 86400,
            "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
            "uuid": "5c6b31fc-885c-4bdb-9b6b-2c2edf28294a",
            "test-status": 0,
            "test-flags": {
                "has-serial-term-with-correctly-length": false,
                "has-serial-term-with-correctly-revision-number-format": false,
                "has-serial-term-with-correctly-date-format": false,
                "has-serial-term-correctly-configured": false
            },
            "test-warning-messages": [
                "The 'serial' term does not have an appropriate number of characters, as it does not use the standard format it is not possible to ensure when one zone is earlier or later than another"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The 'serial' term does not have an appropriate number of characters, as it does not use the standard format it is not possible to ensure when one zone is earlier or later than another"
    ],
    "test-info-messages": [
        "The term must have the format YYYYMMDDXX, this format uses 10 digits to represent the date and then a two-digit sequence number"
    ]
}

Slug: serial-term

Description

This test check that the term serial of the SOA record has te recommended format YYYYMMDDXX. This format uses 10 digits to represent the date and a two-digit sequence number. You can see the MXtoolbox docs.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SOA>`	No	SOA records of domain. Only should send one record.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SOA type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	The serial term has the format `YYYYMMDDXX`.
Warning	`0`	The serial term hasn't the format `YYYYMMDDXX`.

Output element test flags

Key	Description
has-serial-term-with-correctly-length	If affirmative, this flag indicates that the serial term has 10 characters of length.
has-serial-term-with-correctly-revision-number-format	If affirmative, this flag indicates that the serial term revision number part has a correct format (the last two characters are integer positive digits).
has-serial-term-with-correctly-date-format	If affirmative, this flag indicates that the serial term date part has a correct format like `YYYYMMDD` (year, month, day).
has-serial-term-correctly-configured	If affirmative, this flag indicates that the serial term has the recommended format `YYYYMMDDXX`.

Refresh term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "SOA",
    "test-name" => "refresh-term",
    "test-params" => [
        "records" => [
          // Optional SOA record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "refresh-term",
    "test-params": {
        "records": [
          # Optional SOA record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "refresh-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "refresh-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "refresh-term",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "ttl": 86400,
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
                "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "SOA",
            "ttl": 86400,
            "serial": 1,
            "refresh": 7200,
            "retry": 900,
            "expiry": 1209600,
            "mname": "ns-1222.awsdns-24.org.",
            "rname": "awsdns-hostmaster.amazon.com.",
            "minimum": 86400,
            "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
            "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8",
            "test-status": 1,
            "test-flags": {
                "has-refresh-term-in-optimal-range": true,
                "has-refresh-term-in-recommended-range": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term 'refresh' has a value within the optimal range"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The optimal refresh range is ( 3600 \u2264  x \u2264 43200 ) and the maximum recommended range is ( 1200 \u2264  x \u2264 86400 )"
    ]
}

Slug: refresh-term

Description

This test check that the term refresh of the SOA record is inside the optimal or recommended ranges. The optimal refresh range is ( 3600 ≤ x ≤ 43200 ) and the maximum recommended range is ( 1200 ≤ x ≤ 86400 ).

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SOA>`	No	SOA records of domain. Only should send one record.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SOA type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	The refresh term in inside the optimal range ( 3600 ≤ x ≤ 43200 ).
Warning	`0`	The refresh term in inside the recommended range ( 1200 ≤ x ≤ 86400 ).
Fail	`-1`	The refresh term is out the any range.

Output element test flags

Key	Description
has-refresh-term-in-optimal-range	The refresh term in inside the optimal range ( 3600 ≤ x ≤ 43200 ).
has-refresh-term-in-recommended-range	The refresh term in inside the recommended range ( 1200 ≤ x ≤ 86400 ).

Retry term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "SOA",
    "test-name" => "retry-term",
    "test-params" => [
        "records" => [
          // Optional SOA record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "retry-term",
    "test-params": {
        "records": [
          # Optional SOA record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "retry-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "retry-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "retry-term",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "ttl": 86400,
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
                "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "SOA",
            "ttl": 86400,
            "serial": 1,
            "refresh": 7200,
            "retry": 900,
            "expiry": 1209600,
            "mname": "ns-1222.awsdns-24.org.",
            "rname": "awsdns-hostmaster.amazon.com.",
            "minimum": 86400,
            "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
            "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8",
            "test-status": 1,
            "test-flags": {
                "has-retry-term-in-optimal-range": true,
                "has-retry-term-in-recommended-range": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term 'retry' has a value within the optimal range"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The optimal retry range is ( 900 \u2264  x \u2264 7200 ) and the maximum recommended range is ( 120 \u2264  x \u2264 43200 )"
    ]
}

Slug: retry-term

Description

This test check that the term retry of the SOA record is inside the optimal or recommended ranges. The optimal retry range is ( 900 ≤ x ≤ 7200 ) and the maximum recommended range is ( 120 ≤ x ≤ 43200 ).

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SOA>`	No	SOA records of domain. Only should send one record.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SOA type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	The retry term in inside the optimal range ( 900 ≤ x ≤ 7200 ).
Warning	`0`	The retry term in inside the recommended range ( 120 ≤ x ≤ 43200 ).
Fail	`-1`	The retry term is out the any range.

Output element test flags

Key	Description
has-retry-term-in-optimal-range	The retry term in inside the optimal range ( 900 ≤ x ≤ 7200 ).
has-retry-term-in-recommended-range	The retry term in inside the recommended range ( 120 ≤ x ≤ 43200 ).

Expiry term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "SOA",
    "test-name" => "expiry-term",
    "test-params" => [
        "records" => [
          // Optional SOA record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "expiry-term",
    "test-params": {
        "records": [
          # Optional SOA record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "expiry-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "expiry-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "expiry-term",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "ttl": 86400,
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
                "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "SOA",
            "ttl": 86400,
            "serial": 1,
            "refresh": 7200,
            "retry": 900,
            "expiry": 1209600,
            "mname": "ns-1222.awsdns-24.org.",
            "rname": "awsdns-hostmaster.amazon.com.",
            "minimum": 86400,
            "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
            "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8",
            "test-status": 1,
            "test-flags": {
                "has-expiry-term-in-optimal-range": true,
                "has-expiry-term-in-recommended-range": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term 'expiry' has a value within the optimal range"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The optimal expiry range is ( 604800 \u2264  x \u2264 1209600 ) and the maximum recommended range is ( 604800 \u2264  x \u2264 60480000 )"
    ]
}

Slug: expiry-term

Description

This test check that the term expiry of the SOA record is inside the optimal or recommended ranges. The optimal expiry range is ( 604800 ≤ x ≤ 1209600 ) and the maximum recommended range is ( 604800 ≤ x ≤ 60480000 ).

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SOA>`	No	SOA records of domain. Only should send one record.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SOA type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	The expiry term in inside the optimal range ( 604800 ≤ x ≤ 1209600 ).
Warning	`0`	The expiry term in inside the recommended range ( 604800 ≤ x ≤ 60480000 ).
Fail	`-1`	The expiry term is out the any range.

Output element test flags

Key	Description
has-expiry-term-in-optimal-range	The expiry term in inside the optimal range ( 604800 ≤ x ≤ 1209600 ).
has-expiry-term-in-recommended-range	The expiry term in inside the recommended range ( 604800 ≤ x ≤ 60480000 ).

Minimum term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "SOA",
    "test-name" => "minimum-term",
    "test-params" => [
        "records" => [
          // Optional SOA record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "minimum-term",
    "test-params": {
        "records": [
          # Optional SOA record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "minimum-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SOA",
  "test-name": "minimum-term",
  "test-params": {
      "records": [
        // Optional SOA record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SOA",
    "test-name": "minimum-term",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "SOA",
                "ttl": 86400,
                "serial": 1,
                "refresh": 7200,
                "retry": 900,
                "expiry": 1209600,
                "mname": "ns-1222.awsdns-24.org.",
                "rname": "awsdns-hostmaster.amazon.com.",
                "minimum": 86400,
                "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
                "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "SOA",
            "ttl": 86400,
            "serial": 1,
            "refresh": 7200,
            "retry": 900,
            "expiry": 1209600,
            "mname": "ns-1222.awsdns-24.org.",
            "rname": "awsdns-hostmaster.amazon.com.",
            "minimum": 86400,
            "value": "ns-1222.awsdns-24.org. awsdns-hostmaster.amazon.com. 1 7200 900 1209600 86400",
            "uuid": "8cc27b19-a44a-4280-9e61-7ffca5d677a8",
            "test-status": 1,
            "test-flags": {
                "has-minimum-term-in-optimal-range": true,
                "has-minimum-term-in-recommended-range": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term 'minimum' has a value within the optimal range"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "The optimal minimum range is ( 3600 \u2264  x \u2264 86400 ) and the maximum recommended range is ( 180 \u2264  x \u2264 604800 )"
    ]
}

Slug: minimum-term

Description

This test check that the term minimum of the SOA record is inside the optimal or recommended ranges. The optimal minimum range is ( 3600 ≤ x ≤ 86400 ) and the maximum recommended range is ( 180 ≤ x ≤ 604800 ).

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SOA>`	No	SOA records of domain. Only should send one record.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SOA type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	The minimum term in inside the optimal range ( 3600 ≤ x ≤ 86400 ).
Warning	`0`	The minimum term in inside the recommended range ( 180 ≤ x ≤ 604800 ).
Fail	`-1`	The minimum term is out the any range.

Output element test flags

Key	Description
has-minimum-term-in-optimal-range	The minimum term in inside the optimal range ( 3600 ≤ x ≤ 86400 ).
has-minimum-term-in-recommended-range	The minimum term in inside the recommended range ( 180 ≤ x ≤ 604800 ).

Target host records tests

Types: TARGET_HOST, A, AAAA or CNAME.

This section describes the tests of the A, AAAA, CNAME records.

The Type TARGET_HOST is the set of the types A, AAAA and CNAME. That means that if you specify a test of the type TARGET_HOST and you do not send some records explicitly then all types will be retrieved automatically.

From the CNAME type only the subdomain www.{domain}.{suffix} is queried. CNAME records cannot be retrieved you have to query for the specific subdomain.

Record has recommended TTL range test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "TARGET_HOST",
    "test-name" => "records-has-recommended-ttl-range",
    "test-params" => [
        "records" => [
          // Optional A or AAAA or CNAME records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "TARGET_HOST",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
          # Optional A or AAAA or CNAME records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "TARGET_HOST",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional A or AAAA or CNAME records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "TARGET_HOST",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional A or AAAA or CNAME records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "TARGET_HOST",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "A",
                "value": "201.46.113.251",
                "ttl": 86400,
                "uuid": "1411dd2d-b34d-4a60-9df1-45ccb92fbbea",
                "ip-host-name": "ip-201-46-113-251.ipinversa.es"
            },
            {
                "host": "www.raiolanetworks.com",
                "type": "CNAME",
                "value": "raiolanetworks.com",
                "ttl": 86400,
                "uuid": "857beb26-9336-49e7-9dea-8b49dfa6a5dc",
                "ipv4": "201.46.113.251",
                "ipv6": null
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "A",
            "value": "201.46.113.251",
            "ttl": 86400,
            "uuid": "6747064b-e8b8-4b53-973e-8889b3396e0a",
            "ip-host-name": "ip-201-46-113-251.ipinversa.es",
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        },
        {
            "host": "www.raiolanetworks.com",
            "type": "CNAME",
            "value": "raiolanetworks.com",
            "ttl": 86400,
            "uuid": "283ab2ec-5f83-431e-9f02-34dfc5a4abea",
            "ipv4": "201.46.113.251",
            "ipv6": null,
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The record 201.46.113.251 has a TTL out of the optimal range for its type",
        "The record raiolanetworks.com has a TTL out of the optimal range for its type"
    ],
    "test-info-messages": [
        "The optimal TTL range for the A records is ( 3600 \u2264  x \u2264 14400 ) and the maximum recommended range is ( 300 \u2264  x \u2264 86400 )",
        "The optimal TTL range for the CNAME records is ( 3600 \u2264  x \u2264 14400 ) and the maximum recommended range is ( 300 \u2264  x \u2264 86400 )"
    ]
}

Slug: records-has-recommended-ttl-range

Description

The A, AAAA and CNAME records optimal range is ( 3600 ≤ x ≤ 14400 ), meaning between 1 hour and 4 hours. The recommended range is ( 300 ≤ x ≤ 86400 ), meaning between 5 minutes and 24 hours.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<A/AAAA/CNAME>`	No	TARGET_HOST records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the A type, AAAA type and CNAME type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has optimal TTL.
Warning	`0`	Some records has optimal TTL, an others has recommended TTL but none is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).
Fail	`-1`	Some records is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).

Output element test flags

Key	Description
has-recommended-ttl	If affirmative, this flag indicates that the analysed record has a optimal or recommended TTL.

MX tests

Type: MX

This section describes the tests of the MX records.

Target hosts with resolvable IPs test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "MX",
    "test-name" => "records-has-recommended-ttl-range",
    "test-params" => [
        "records" => [
          // Optional MX records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "MX",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
          # Optional MX records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "MX",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "MX",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "MX",
    "test-name": "target-hosts-with-resolvable-ips",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "aspmx.l.google.com",
                "ttl": 86400,
                "level": 1,
                "uuid": "9fa6af8f-fc66-4e74-9981-2548e9c60c86",
                "ipv4": "64.233.184.26",
                "ipv6": "2a00:1450:400c:c09::1b"
            },
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "alt1.aspmx.l.google.com",
                "ttl": 86400,
                "level": 5,
                "uuid": "f2385c58-a638-4f2f-8d96-1bcbc772aaa9",
                "ipv4": "142.250.153.26",
                "ipv6": "2a00:1450:4013:c16::1b"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "aspmx.l.google.com",
            "ttl": 86400,
            "level": 1,
            "uuid": "6b8a9d5b-bd9c-4a47-a542-dfc1af6d0dc4",
            "ipv4": "142.250.110.26",
            "ipv6": "2a00:1450:400c:c0d::1b",
            "test-status": 1,
            "test-flags": {
                "has-any-resolvable-ip": true
            },
            "test-warning-messages": []
        },
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "alt1.aspmx.l.google.com",
            "ttl": 86400,
            "level": 5,
            "uuid": "7ed638cc-ccfc-4fda-8c5a-dcb28448e59c",
            "ipv4": "142.250.153.26",
            "ipv6": "2a00:1450:4013:c16::1b",
            "test-status": 1,
            "test-flags": {
                "has-any-resolvable-ip": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "All records have a target that points to a host with at least one resolvable IP (IPv4 or IPv6)"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: target-hosts-with-resolvable-ips

Description

This test check that the hosts to which the records point have resolvable ips, at least one IP (IPv4 or IPv6).

Test parameters

Parameter	Type	Mandatory	Description
records	`array<MX>`	No	MX records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the MX type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has hosts with resolvable IPs.
Fail	`-1`	Some records has hosts with irresolvable IPs.

Output element test flags

Key	Description
has-any-resolvable-ip	If affirmative, this flag indicates that the analysed record has at least one resolvable IP.

Duplicated records test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "MX",
    "test-name" => "duplicated-records",
    "test-params" => [
        "records" => [
          // Optional MX records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "MX",
    "test-name": "duplicated-records",
    "test-params": {
        "records": [
          # Optional MX records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "MX",
  "test-name": "duplicated-records",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "MX",
  "test-name": "duplicated-records",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "MX",
    "test-name": "duplicated-records",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "aspmx.l.google.com",
                "ttl": 86400,
                "level": 1,
                "uuid": "fac7f265-7bdb-4bd9-9dff-0565055ec709",
                "ipv4": "74.125.133.26",
                "ipv6": "2a00:1450:400c:c0a::1b"
            },
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "alt1.aspmx.l.google.com",
                "ttl": 86400,
                "level": 5,
                "uuid": "f978eb48-3693-468e-8e11-d73d5177f3c9",
                "ipv4": "142.250.153.26",
                "ipv6": "2a00:1450:4013:c16::1b"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "aspmx.l.google.com",
            "ttl": 86400,
            "level": 1,
            "uuid": "fac7f265-7bdb-4bd9-9dff-0565055ec709",
            "ipv4": "74.125.133.26",
            "ipv6": "2a00:1450:400c:c0a::1b",
            "test-status": 1,
            "test-flags": {
                "has-duplicated-host-name": false
            },
            "test-warning-messages": []
        },
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "alt1.aspmx.l.google.com",
            "ttl": 86400,
            "level": 5,
            "uuid": "f978eb48-3693-468e-8e11-d73d5177f3c9",
            "ipv4": "142.250.153.26",
            "ipv6": "2a00:1450:4013:c16::1b",
            "test-status": 1,
            "test-flags": {
                "has-duplicated-host-name": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "No hostnames are repeated in the record targets"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: duplicated-records

Description

This test check that the hosts which the records point are not repeated between the MX records.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<MX>`	No	MX records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the MX type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	No repeat hosts.
Fail	`-1`	There are repeat hosts.

Output element test flags

Key	Description
has-duplicated-host-name	If affirmative, this flag indicates that are repeat hosts.

No records points to CNAME test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "MX",
    "test-name" => "no-records-points-to-cname",
    "test-params" => [
        "records" => [
          // Optional MX records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "MX",
    "test-name": "no-records-points-to-cname",
    "test-params": {
        "records": [
          # Optional MX records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "MX",
  "test-name": "no-records-points-to-cname",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "MX",
  "test-name": "no-records-points-to-cname",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "MX",
    "test-name": "no-records-points-to-cname",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "aspmx.l.google.com",
                "ttl": 86400,
                "level": 1,
                "uuid": "fac7f265-7bdb-4bd9-9dff-0565055ec709",
                "ipv4": "74.125.133.26",
                "ipv6": "2a00:1450:400c:c0a::1b"
            },
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "alt1.aspmx.l.google.com",
                "ttl": 86400,
                "level": 5,
                "uuid": "f978eb48-3693-468e-8e11-d73d5177f3c9",
                "ipv4": "142.250.153.26",
                "ipv6": "2a00:1450:4013:c16::1b"
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "aspmx.l.google.com",
            "ttl": 86400,
            "level": 1,
            "uuid": "fac7f265-7bdb-4bd9-9dff-0565055ec709",
            "ipv4": "74.125.133.26",
            "ipv6": "2a00:1450:400c:c0a::1b",
            "test-status": 1,
            "test-flags": {
                "points-to-cname": false,
                "is-resolvable": true
            },
            "test-warning-messages": []
        },
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "alt1.aspmx.l.google.com",
            "ttl": 86400,
            "level": 5,
            "uuid": "f978eb48-3693-468e-8e11-d73d5177f3c9",
            "ipv4": "142.250.153.26",
            "ipv6": "2a00:1450:4013:c16::1b",
            "test-status": 1,
            "test-flags": {
                "points-to-cname": false,
                "is-resolvable": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "No record has a value that points to a CNAME record"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: no-records-points-to-cname

Description

This test check that the hosts which the records point are not CNAME records.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<MX>`	No	MX records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the MX type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	No CNAME hosts.
Warning	`0`	There are CNAME hosts.
Fail	`-1`	Erron in DNS requests when check CNAME records.

Output element test flags

Key	Description
points-to-cname	If affirmative, this flag indicates that the records points to CNAME host.
is-resolvable	If affirmative, this flag indicates that the host to which the record points are resolvable.

Record has recommended TTL range test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "MX",
    "test-name" => "records-has-recommended-ttl-range",
    "test-params" => [
        "records" => [
          // Optional MX records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "MX",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
          # Optional MX records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "MX",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "MX",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional MX records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "MX",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "aspmx.l.google.com",
                "ttl": 86400,
                "level": 1,
                "uuid": "ceaa22d7-6722-4c09-8f2c-d125cd5f0da2",
                "ipv4": "173.194.76.26",
                "ipv6": "2a00:1450:400c:c09::1b"
            },
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "alt1.aspmx.l.google.com",
                "ttl": 86400,
                "level": 5,
                "uuid": "59194562-512d-4ec6-b4df-16d4ece59d81",
                "ipv4": "142.250.153.27",
                "ipv6": "2a00:1450:4013:c16::1b"
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "aspmx.l.google.com",
            "ttl": 86400,
            "level": 1,
            "uuid": "6b8a9d5b-bd9c-4a47-a542-dfc1af6d0dc4",
            "ipv4": "142.250.110.26",
            "ipv6": "2a00:1450:400c:c0d::1b",
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        },
        {
            "host": "raiolanetworks.com",
            "type": "MX",
            "value": "alt1.aspmx.l.google.com",
            "ttl": 86400,
            "level": 5,
            "uuid": "7ed638cc-ccfc-4fda-8c5a-dcb28448e59c",
            "ipv4": "142.250.153.26",
            "ipv6": "2a00:1450:4013:c16::1b",
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The record aspmx.l.google.com has a TTL out of the optimal range for its type",
        "The record alt1.aspmx.l.google.... has a TTL out of the optimal range for its type"
    ],
    "test-info-messages": [
        "The optimal TTL range for the MX records is ( 3600 \u2264  x \u2264 14400 ) and the maximum recommended range is ( 300 \u2264  x \u2264 86400 )"
    ]
}

Slug: records-has-recommended-ttl-range

Description

The MX records optimal range is ( 3600 ≤ x ≤ 14400 ), meaning between 1 hour and 4 hours. The recommended range is ( 300 ≤ x ≤ 86400 ), meaning between 5 minutes and 24 hours.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<MX>`	No	MX records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the MX type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has optimal TTL.
Warning	`0`	Some records has optimal TTL, an others has recommended TTL but none is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).
Fail	`-1`	Some records is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).

Output element test flags

Key	Description
has-recommended-ttl	If affirmative, this flag indicates that the analysed record has a optimal or recommended TTL.

TXT tests

Type: TXT

This section describes the tests of the TXT records.

Record has recommended TTL range test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "TXT",
    "test-name" => "records-has-recommended-ttl-range",
    "test-params" => [
        "records" => [
          // Optional TXT records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "TXT",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
          # Optional TXT records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "TXT",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional TXT records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "TXT",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional TXT records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "TXT",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
            {
                "host": "raiolanetworks.com",
                "type": "TXT",
                "value": "ahrefs-site-verification_105b0a0c2c9516ee80425fbbdd52641bb249117dc593c78047eeca48747f5ddf",
                "ttl": 86400,
                "uuid": "d269c522-6bbf-404a-8ea7-ee19a8a5ad76"
            },
            {
                "host": "raiolanetworks.com",
                "type": "TXT",
                "value": "facebook-domain-verification=ayb0ojfs7m8at84v8e96lfbdk1wkg8",
                "ttl": 86400,
                "uuid": "ea8b0ba3-f141-4d9b-b905-7cadba8d8817"
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "host": "raiolanetworks.com",
            "type": "TXT",
            "value": "ahrefs-site-verification_105b0a0c2c9516ee80425fbbdd52641bb249117dc593c78047eeca48747f5ddf",
            "ttl": 86400,
            "uuid": "5b740353-a526-4ac0-bc54-1dcf8a9dd551",
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        },
        {
            "host": "raiolanetworks.com",
            "type": "TXT",
            "value": "facebook-domain-verification=ayb0ojfs7m8at84v8e96lfbdk1wkg8",
            "ttl": 86400,
            "uuid": "6a38801e-acfb-4d59-9f6b-d3f90bda2e7e",
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The record ahrefs-site-verifica... has a TTL out of the optimal range for its type",
        "The record facebook-domain-veri... has a TTL out of the optimal range for its type"
    ],
    "test-info-messages": [
        "The optimal TTL range for the TXT records is ( 3600 \u2264  x \u2264 14400 ) and the maximum recommended range is ( 300 \u2264  x \u2264 86400 )"
    ]
}

Slug: records-has-recommended-ttl-range

Description

The TXT records optimal range is ( 3600 ≤ x ≤ 14400 ), meaning between 1 hour and 4 hours. The recommended range is ( 300 ≤ x ≤ 86400 ), meaning between 5 minutes and 24 hours.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<TXT>`	No	TXT records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the TXT type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has optimal TTL.
Warning	`0`	Some records has optimal TTL, an others has recommended TTL but none is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).
Fail	`-1`	Some records is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).

Output element test flags

Key	Description
has-recommended-ttl	If affirmative, this flag indicates that the analysed record has a optimal or recommended TTL.

SPF tests

Type: SPF

This section describes the tests of the SPF record.

Has only one SPF record and in correct format test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1222.awsdns-24.org",
    "type" => "SPF",
    "test-name" => "has-only-one-spf-and-correct-format",
    "test-params" => [
        "records" => [
          // Optional SPF record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SPF",
    "test-name": "has-only-one-spf-and-correct-format",
    "test-params": {
        "records": [
          # Optional SPF record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SPF",
  "test-name": "has-only-one-spf-and-correct-format",
  "test-params": {
      "records": [
        // Optional SPF record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1222.awsdns-24.org",
  "type": "SPF",
  "test-name": "has-only-one-spf-and-correct-format",
  "test-params": {
      "records": [
        // Optional SPF record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1222.awsdns-24.org",
    "type": "SPF",
    "test-name": "has-only-one-spf-and-correct-format",
    "test-params": {
        "records": [
            {
                "uuid": "307a2397-8590-4c42-9fbb-ba4801078e42",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "307a2397-8590-4c42-9fbb-ba4801078e42",
            "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
            "processed-correctly": true,
            "terms": {
                "authorise-own-a-records": true,
                "authorise-own-mx-records": true,
                "authorise-own-ptr": false,
                "a": [],
                "mx": [],
                "ptr": [],
                "exists": [],
                "ips": [
                    {
                        "qualifier": "+",
                        "network": "178.32.28.33"
                    }
                ],
                "exp": null,
                "redirect": null,
                "all": "-all",
                "includes": [
                    {
                        "qualifier": "+",
                        "hostname": "mailgun.org"
                    },
                    {
                        "qualifier": "+",
                        "hostname": "_spf.google.com"
                    },
                    {
                        "qualifier": "+",
                        "hostname": "amazonses.com"
                    }
                ]
            },
            "test-status": 1,
            "test-flags": {
                "there-is-only-one-record": true,
                "has-valid-format": true
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "There is only one SPF record in the TXT records",
        "The SPF record has a correct format"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "RFC on the SPF record format: datatracker.ietf.org\/doc\/html\/rfc7208#section-3"
    ]
}

Slug: has-only-one-spf-and-correct-format

Description

This test check that the only exists one SPF record between TXT record and it has a correct format.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SPF>`	No	SPF records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SPF type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	The SPF record its the unique record between TXT records and has a correct format.
Fail	`-1`	There are 0 or more than 1 SPF records between TXT records or the records has invalid format.

Output element test flags

Key	Description
there-is-only-one-record	If affirmative, this flag indicates that only has one SPF record between TXT records.
has-valid-format	If affirmative, this flag indicates that the SPF record format is valid.

Records hosts can send emails test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "SPF",
    "test-name" => "records-hosts-can-send-emails",
    "test-params" => [
        "mode" => "a",
        "records" => [
          // Optional SPF record object
        ],
        "a-records" => [
          // Optional A records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SPF",
    "test-name": "records-hosts-can-send-emails",
    "test-params": {
        "mode": "a",
        "records": [
          # Optional SPF record object
        ],
        "a-records": [
          # Optional A records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SPF",
  "test-name": "records-hosts-can-send-emails",
  "test-params": {
      "mode": "a",
      "records": [
        // Optional SPF record object
      ],
      "a-records": [ 
        // Optional A records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SPF",
  "test-name": "records-hosts-can-send-emails",
  "test-params": {
      "mode": "a",
      "records": [
        // Optional SPF record object
      ],
      "a-records": [
        // Optional A records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters for A mode example:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SPF",
    "test-name": "records-hosts-can-send-emails",
    "test-params": {
        "mode": "a",
        "records": [
            {
                "uuid": "d373bd6f-5e47-4e28-8451-e781392a8676",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                }
            }
        ],
        "a-records": [
            {
                "host": "raiolanetworks.com",
                "type": "A",
                "value": "201.46.113.251",
                "ttl": 86400,
                "uuid": "9805e785-b05b-41f9-9230-ff068f5fec75",
                "ip-host-name": "ip-201-46-113-251.ipinversa.es"
            }
        ]
    }
}

Response for A mode example:

{
    "test-status": 1,
    "output-elements": {
        "records": [
            {
                "uuid": "d373bd6f-5e47-4e28-8451-e781392a8676",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                },
                "test-status": 1,
                "test-flags": {
                    "all-a-records-can-send-emails": true
                },
                "test-warning-messages": []
            }
        ],
        "a-records": [
            {
                "host": "raiolanetworks.com",
                "type": "A",
                "value": "201.46.113.251",
                "ttl": 86400,
                "uuid": "9805e785-b05b-41f9-9230-ff068f5fec75",
                "ip-host-name": "ip-201-46-113-251.ipinversa.es",
                "test-status": 1,
                "test-flags": {
                    "host-can-send-emails": true
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "All hosts of the records can send emails with the domain name"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Json parameters for MX mode example:

{
    "test-status": 1,
    "output-elements": {
        "records": [
            {
                "uuid": "d373bd6f-5e47-4e28-8451-e781392a8676",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                },
                "test-status": 1,
                "test-flags": {
                    "all-mx-records-can-send-emails": true
                },
                "test-warning-messages": []
            }
        ],
        "mx-records": [
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "aspmx.l.google.com",
                "ttl": 86400,
                "level": 1,
                "uuid": "8f1be5cf-406f-4475-8162-6b3b638ecdd1",
                "ipv4": "74.125.133.26",
                "ipv6": "2a00:1450:400c:c0a::1b",
                "test-status": 1,
                "test-flags": {
                    "host-can-send-emails": true
                },
                "test-warning-messages": []
            },
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "alt1.aspmx.l.google.com",
                "ttl": 86400,
                "level": 5,
                "uuid": "90a78b39-ec31-4fde-a296-0cdf1cb5e25e",
                "ipv4": "142.250.153.27",
                "ipv6": "2a00:1450:4013:c16::1a",
                "test-status": 1,
                "test-flags": {
                    "host-can-send-emails": true
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "All hosts of the records can send emails with the domain name"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Response for MX mode example:

{
    "test-status": 1,
    "output-elements": {
        "records": [
            {
                "uuid": "d373bd6f-5e47-4e28-8451-e781392a8676",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                },
                "test-status": 1,
                "test-flags": {
                    "all-mx-records-can-send-emails": true
                },
                "test-warning-messages": []
            }
        ],
        "mx-records": [
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "aspmx.l.google.com",
                "ttl": 86400,
                "level": 1,
                "uuid": "8f1be5cf-406f-4475-8162-6b3b638ecdd1",
                "ipv4": "74.125.133.26",
                "ipv6": "2a00:1450:400c:c0a::1b",
                "test-status": 1,
                "test-flags": {
                    "host-can-send-emails": true
                },
                "test-warning-messages": []
            },
            {
                "host": "raiolanetworks.com",
                "type": "MX",
                "value": "alt1.aspmx.l.google.com",
                "ttl": 86400,
                "level": 5,
                "uuid": "90a78b39-ec31-4fde-a296-0cdf1cb5e25e",
                "ipv4": "142.250.153.27",
                "ipv6": "2a00:1450:4013:c16::1a",
                "test-status": 1,
                "test-flags": {
                    "host-can-send-emails": true
                },
                "test-warning-messages": []
            }
        ]
    },
    "test-successful-messages": [
        "All hosts of the records can send emails with the domain name"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: records-hosts-can-send-emails

Description

This test check that the the hosts to which the records A, AAAA and MX points are enabled to send email according to the configuration set in the SPF record. For example, it is checked that the hosts of an A record is able to send emails according to the rules defined in the SPF.

This test has two modes, On the one hand, a mode is for A and AAAA records, on the other hand, the mxmode is for MXrecords. When use a mode you must send the A and AAAA with a-records parameter key, if you use mx you must send the the MX records with mx-records key. When this elements are returned in the response will come with the same keys in the output-elements.

Test parameters

Parameter	Type	Mandatory	Description
mode	`string`	No	The mode of the test, for A and AAAA record or MX records. It can has two values, `a` and `mx`, by default work with `a` mode.
records	`array<SPF>`	No	SPF records of domain. Only should send one record.
a-records	`array<A/AAAA>`	No	A or AAAA records of domain.
mx-records	`array<MX>`	No	MX records of domain.

The parameter "records, "a-records" and "mx-records" aren't mandatory, this parameters are a auto-recovery params, you can see the section of Auto-recovery of test params.

See the SPF type to see the type of record that can be sent.

See the A type to see the type of records that can be sent.

See the AAAA type to see the type of records that can be sent.

See the MX type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All analyzed records can send emails.
Fail	`-1`	Some analyzed records can't send emails.

Output element test flags for SPF record

Key	Description
all-mx-records-can-send-emails	If affirmative, this flag indicates that all MX records can send emails according to the SPF configuration.
all-a-records-can-send-emails	If affirmative, this flag indicates that all A and AAAA records can send emails according to the SPF configuration.

Output element test flags for target host records (A, AAAA and MX)

Key	Description
host-can-send-emails	If affirmative, this flag indicates that the host which the record point can send emails according to the SPF configuration.

PTR mechanism not recommended test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "SPF",
    "test-name" => "ptr-not-recommended",
    "test-params" => [
        "records" => [
          // Optional SPF record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SPF",
    "test-name": "ptr-not-recommended",
    "test-params": {
        "records": [
          # Optional SPF record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SPF",
  "test-name": "ptr-not-recommended",
  "test-params": {
      "records": [
        // Optional SPF record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SPF",
  "test-name": "ptr-not-recommended",
  "test-params": {
      "records": [
        // Optional SPF record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SPF",
    "test-name": "ptr-not-recommended",
    "test-params": {
        "records": [
            {
                "uuid": "42e12ac0-77c6-4f36-9293-9eaf05fdac29",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "42e12ac0-77c6-4f36-9293-9eaf05fdac29",
            "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
            "processed-correctly": true,
            "terms": {
                "authorise-own-a-records": true,
                "authorise-own-mx-records": true,
                "authorise-own-ptr": false,
                "a": [],
                "mx": [],
                "ptr": [],
                "exists": [],
                "ips": [
                    {
                        "qualifier": "+",
                        "network": "178.32.28.33"
                    }
                ],
                "exp": null,
                "redirect": null,
                "all": "-all",
                "includes": [
                    {
                        "qualifier": "+",
                        "hostname": "mailgun.org"
                    },
                    {
                        "qualifier": "+",
                        "hostname": "_spf.google.com"
                    },
                    {
                        "qualifier": "+",
                        "hostname": "amazonses.com"
                    }
                ]
            },
            "test-status": 1,
            "test-flags": {
                "uses-ptr-term": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The PTR mechanism is not used in the SPF record"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "RFC on the use of the PTR mechanism: datatracker.ietf.org\/doc\/html\/rfc7208#section-5.5"
    ]
}

Slug: ptr-not-recommended

Description

This test check that the SPF record not uses the PTR term. This mechanism is not recommended because has slow performance.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SPF>`	No	SPF records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SPF type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	The SPF record uses the PTR term.
Warning	`0`	The SPF not record uses the PTR term.
Fail	`-1`	Error in SPF term processing.

Output element test flags

Key	Description
uses-ptr-term	If affirmative, this flag indicates the SPF record uses the PTR term.

All term is correctly configured test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "SPF",
    "test-name" => "all-term-is-correctly",
    "test-params" => [
        "records" => [
          // Optional SPF record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SPF",
    "test-name": "all-term-is-correctly",
    "test-params": {
        "records": [
          # Optional SPF record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SPF",
  "test-name": "all-term-is-correctly",
  "test-params": {
      "records": [
        // Optional SPF record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "SPF",
  "test-name": "all-term-is-correctly",
  "test-params": {
      "records": [
        // Optional SPF record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "SPF",
    "test-name": "all-term-is-correctly",
    "test-params": {
        "records": [
            {
                "uuid": "42e12ac0-77c6-4f36-9293-9eaf05fdac29",
                "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
                "processed-correctly": true,
                "terms": {
                    "authorise-own-a-records": true,
                    "authorise-own-mx-records": true,
                    "authorise-own-ptr": false,
                    "a": [],
                    "mx": [],
                    "ptr": [],
                    "exists": [],
                    "ips": [
                        {
                            "qualifier": "+",
                            "network": "178.32.28.33"
                        }
                    ],
                    "exp": null,
                    "redirect": null,
                    "all": "-all",
                    "includes": [
                        {
                            "qualifier": "+",
                            "hostname": "mailgun.org"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "_spf.google.com"
                        },
                        {
                            "qualifier": "+",
                            "hostname": "amazonses.com"
                        }
                    ]
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "42e12ac0-77c6-4f36-9293-9eaf05fdac29",
            "record": "v=spf1 a mx include:mailgun.org include:_spf.google.com include:amazonses.com ip4:178.32.28.33 -all",
            "processed-correctly": true,
            "terms": {
                "authorise-own-a-records": true,
                "authorise-own-mx-records": true,
                "authorise-own-ptr": false,
                "a": [],
                "mx": [],
                "ptr": [],
                "exists": [],
                "ips": [
                    {
                        "qualifier": "+",
                        "network": "178.32.28.33"
                    }
                ],
                "exp": null,
                "redirect": null,
                "all": "-all",
                "includes": [
                    {
                        "qualifier": "+",
                        "hostname": "mailgun.org"
                    },
                    {
                        "qualifier": "+",
                        "hostname": "_spf.google.com"
                    },
                    {
                        "qualifier": "+",
                        "hostname": "amazonses.com"
                    }
                ]
            },
            "test-status": 1,
            "test-flags": {
                "all-term-not-exist": false,
                "all-term-is-correctly-with-hard-fail-qualifier": true,
                "all-term-is-not-correctly-with-soft-fail-qualifier": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The 'all' term of the SPF record is correctly configured with hard fail qualifier '-all'"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: all-term-is-correctly

Description

The "all" term in theSPF record specify how to handle emails from unauthorized IP addresses. It has several modifiers:

-all (reject unauthorized emails).
~all (soft fail, accept but mark as suspicious).
?all (neutral, no specific action).
+all (allow any IP, effectively disabling SPF).

His ensures proper email authentication and reduces spoofing.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<SPF>`	No	SPF records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the SPF type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	The SPF has hard fail qualifier `-all`.
Warning	`0`	The SPF not has all term or has soft fail qualifier `~all`.
Fail	`-1`	The SPF has `+all`.

Output element test flags

Key	Description
all-term-not-exist	If affirmative, this flag indicates the all term not exists.
all-term-is-correctly-with-hard-fail-qualifier	If affirmative, this flag indicates the all term is hard fail qualifier `-all`.
all-term-is-not-correctly-with-soft-fail-qualifier	If affirmative, this flag indicates the all term is soft fail qualifier `~all`.

DMARC tests

Type: DMARC

This section describes the tests of the DMARC record.

Has only one DMARC record and in correct format test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "DMARC",
    "test-name" => "has-only-one-dmarc-and-correct-format",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "DMARC",
    "test-name": "has-only-one-dmarc-and-correct-format",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "DMARC",
  "test-name": "has-only-one-dmarc-and-correct-format",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "DMARC",
  "test-name": "has-only-one-dmarc-and-correct-format",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "DMARC",
    "test-name": "has-only-one-dmarc-and-correct-format",
    "test-params": {
        "records": [
            {
                "uuid": "88f321d9-06c2-4b0f-9ec2-abd99e77fd06",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "88f321d9-06c2-4b0f-9ec2-abd99e77fd06",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 1,
            "test-flags": [],
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "There is only one DMARC record in the TXT records",
        "The DMARC record has a correct format"
    ],
    "test-warning-messages": [],
    "test-info-messages": [
        "RFC on the DMARC record format: datatracker.ietf.org\/doc\/html\/rfc7489#section-6.3"
    ]
}

Slug: has-only-one-dmarc-and-correct-format

Description

This test check that the only exists one DMARC record between TXT record of subdomain _dmarc.yourdomain.com (if exists) and it has a correct format.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	The DMARC record its the unique record between TXT records and has a correct format.
Fail	`-1`	There are 0 or more than 1 DMARC records between TXT records or the records has invalid format.

Output element test flags

Key	Description
there-is-only-one-record	If affirmative, this flag indicates that only has one DMARC record between TXT records.
has-valid-format	If affirmative, this flag indicates that the DMARC record format is valid.

Policy term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-1916.awsdns-47.co.uk",
    "type" => "DMARC",
    "test-name" => "policy-term",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "DMARC",
    "test-name": "policy-term",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "DMARC",
  "test-name": "policy-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-1916.awsdns-47.co.uk",
  "type": "DMARC",
  "test-name": "policy-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-1916.awsdns-47.co.uk",
    "type": "DMARC",
    "test-name": "policy-term",
    "test-params": {
        "records": [
            {
                "uuid": "88f321d9-06c2-4b0f-9ec2-abd99e77fd06",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "88f321d9-06c2-4b0f-9ec2-abd99e77fd06",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 1,
            "test-flags": {
                "has-p-with-none-value": false,
                "has-p-with-quarantine-value": false,
                "has-p-with-reject-value": true,
                "no-has-p": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term 'p' (policy) has the value 'reject', this means that when an email fails validations, it will be rejected by the recipient mail server"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: policy-term

Description

The 'p' policy in a DMARC record specifies the action for emails failing DMARC checks.

The policy values are:

none: No specific action is taken on mails that fail DMARC checks, but reports are generated.
quarantine: Mails that fail DMARC checks are treated as suspicious and may be sent to the spam or quarantine folder.
reject: Mails that fail DMARC checks are rejected and not delivered to the addressee.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	Policy term not found or has value `none`.
Warning	`0`	Policy term has value `quarantine`.
Fail	`-1`	Policy term has value `reject`. Or has problems for process the DMARC record.

Output element test flags

Key	Description
has-p-with-none-value	If affirmative, this flag indicates that policy term has value `none`.
has-p-with-quarantine-value	If affirmative, this flag indicates that policy term has value `quarentine`.
has-p-with-reject-value	If affirmative, this flag indicates that policy term has value `reject`.
no-has-p	If affirmative, this flag indicates that policy term not found.

Subdomain policy term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "DMARC",
    "test-name" => "subdomain-policy-term",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "subdomain-policy-term",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "subdomain-policy-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "subdomain-policy-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "subdomain-policy-term",
    "test-params": {
        "records": [
            {
                "uuid": "d6691180-9cee-4bfe-8ec4-067baa3dcd70",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "uuid": "d6691180-9cee-4bfe-8ec4-067baa3dcd70",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 0,
            "test-flags": {
                "has-sp-with-none-value": false,
                "has-sp-with-quarantine-value": true,
                "has-sp-with-reject-value": false,
                "no-has-p": false
            },
            "test-warning-messages": [
                "The 'sp' (subdomain policy) term has the value 'quarantine', which causes emails to be marked as suspicious on the destination mail server instead of being rejected, even if they fail all validations"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The 'sp' (subdomain policy) term has the value 'quarantine', which causes emails to be marked as suspicious on the destination mail server instead of being rejected, even if they fail all validations"
    ],
    "test-info-messages": []
}

Slug: subdomain-policy-term

Description

The 'sp' policy or subdomain policy in a DMARC record specifies the action for emails failing DMARC checks for all subdomains.

The policy values are:

none: No specific action is taken on mails that fail DMARC checks, but reports are generated.
quarantine: Mails that fail DMARC checks are treated as suspicious and may be sent to the spam or quarantine folder.
reject: Mails that fail DMARC checks are rejected and not delivered to the addressee.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	Subdomain policy term not found or has value `none`.
Warning	`0`	Subdomain policy term has value `quarantine`.
Fail	`-1`	Subdomain policy term has value `reject`. Or has problems for process the DMARC record.

Output element test flags

Key	Description
has-sp-with-none-value	If affirmative, this flag indicates that subdomain policy term has value `none`.
has-sp-with-quarantine-value	If affirmative, this flag indicates that subdomain policy term has value `quarentine`.
has-sp-with-reject-value	If affirmative, this flag indicates that subdomain policy term has value `reject`.
no-has-sp	If affirmative, this flag indicates that subdomain policy term not found.

PCT term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "DMARC",
    "test-name" => "pct-term",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "pct-term",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "pct-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "pct-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "pct-term",
    "test-params": {
        "records": [
            {
                "uuid": "d6691180-9cee-4bfe-8ec4-067baa3dcd70",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "d6691180-9cee-4bfe-8ec4-067baa3dcd70",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 1,
            "test-flags": {
                "has-pct": true,
                "no-has-pct-and-use-default-value": false,
                "pct-is-less-than-100": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term has a value of (100). Security measures will be applied to 100% of the sent emails"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: pct-term

Description

The 'pct' term in a DMARC record specifies the percentage of application of 'quarantine' or 'reject' policies.

The percentage value is a positive integer number, can be in the range (1 ≤ X ≤ 100), by default is 100.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	PCT term has value 100 or not defined.
Warning	`0`	PCT term has value less than 100.
Fail	`-1`	Has problems for process the DMARC record.

Output element test flags

Key	Description
has-pct	PCT term is defined.
no-has-pct-and-use-default-value	PCT term isn't defined and use default value (100).
pct-is-less-than-100	PCT term is defined with value less than 100.

Rua and Ruf terms test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "DMARC",
    "test-name" => "rua-and-ruf-terms",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "rua-and-ruf-terms",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "rua-and-ruf-terms",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "rua-and-ruf-terms",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "rua-and-ruf-terms",
    "test-params": {
        "records": [
            {
                "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 0,
            "test-flags": {
                "has-neither-rua-nor-ruf": false,
                "only-has-rua": false,
                "only-has-ruf": false,
                "has-rua-and-ruf": true
            },
            "test-warning-messages": [
                "Both terms ('rua' and 'ruf') are defined. Generally, only 'ruf' should be sufficient, as 'rua' generates daily reports even if there are no validation failures, which may not be necessary"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "Both terms ('rua' and 'ruf') are defined. Generally, only 'ruf' should be sufficient, as 'rua' generates daily reports even if there are no validation failures, which may not be necessary"
    ],
    "test-info-messages": []
}

Slug: rua-and-ruf-terms

Description

The 'rua' term is used to declare URI or URIs to send aggregated validation activity reports. These reports provide a summary of email traffic, showing which messages have passed or failed email policies.

The 'ruf' term is used to declare URI or URIs to send forensic reports of specific validation failures. These reports are more detailed than RUA reports and provide specific information on each message that has failed authentication policies.

This test checks that these terms are used correctly.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	It has 'ruf' but not 'rua'.
Warning	`0`	It has 'rua' but not 'ruf'. Or has both terms, this situation is unnecessary.
Fail	`-1`	It doesn't have neither terms. Or has problems for process the DMARC record.

Output element test flags

Key	Description
has-neither-rua-nor-ruf	It doesn't have neither terms declared ('rua' and 'ruf').
only-has-rua	Only has 'rua' term declared.
only-has-ruf	Only has 'ruf' term declared.
has-rua-and-ruf	Has both terms declared ('rua' and 'ruf').

Fo term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "DMARC",
    "test-name" => "fo-term",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "fo-term",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "fo-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "fo-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "fo-term",
    "test-params": {
        "records": [
            {
                "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 1,
            "test-flags": {
                "no-has-fo-and-use-default-value": true,
                "has-fo-with-0-value": false,
                "has-fo-with-1-value": false,
                "has-fo-with-s-value": false,
                "has-fo-with-d-value": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term is not explicitly defined, so it takes the default value '0'. Reports are sent when both SPF and DKIM fail"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: fo-term

Description

The 'fo' term in a DMARC record specifies the options for forensic reports of messages that fail DMARC authentication. This parameter defines when and how these detailed failure reports are generated.

Values:

0: (default) Reports are sent when both SPF and DKIM fail.
1: Reports are sent when either SPF or DKIM fail (there may be legitimate emails passing only one validation).
d: Reports are sent only when DKIM fails, completely omitting the SPF validation status.
s: Reports are sent only when SPF fails, completely omitting the DKIM validation status.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	Term is undefined (default value) or has `0` value.
Warning	`0`	Has `1` value.
Fail	`-1`	Has `s` or `d` values or has an invalid value. Or has problems for process the DMARC record.

Output element test flags

Key	Description
no-has-fo-and-use-default-value	The term 'fo' is undefined and uses the default value (`0`).
has-fo-with-0-value	The term has `0` value.
has-fo-with-1-value	The term has `1` value.
has-fo-with-s-value	The term has `s` value.
has-fo-with-d-value	The term has `d` value.

ADKIM term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "DMARC",
    "test-name" => "adkim-term",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "adkim-term",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "adkim-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "adkim-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "adkim-term",
    "test-params": {
        "records": [
            {
                "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 1,
            "test-flags": {
                "no-has-adkim-and-use-default-value": true,
                "has-adkim-with-r-value": false,
                "has-adkim-with-s-value": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term is not explicitly defined, so it takes the default value 'r'. DKIM validation accepts emails from the domain and subdomains"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: adkim-term

Description

The 'adkim' term in a DMARC record specifies the DKIM validation alignment, in other words, how DKIM validation is done.

Values:

r: (default) DKIM validation supports mails from domain and subdomains.
s: DKIM validation supports mails only from domain not from subdomains.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	Term is undefined (default value) or has `r` value.
Warning	`0`	Has `s` value.
Fail	`-1`	Has an invalid value. Or has problems for process the DMARC record.

Output element test flags

Key	Description
no-has-adkim-and-use-default-value	The term 'adkim' is undefined and uses the default value (`r`).
has-adkim-with-r-value	The term has `r` value.
has-adkim-with-s-value	The term has `s` value.

ASPF term test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "raiolanetworks.com",
    "target-hostname" => "ns-530.awsdns-02.net",
    "type" => "DMARC",
    "test-name" => "aspf-term",
    "test-params" => [
        "records" => [
          // Optional DMARC record object
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "aspf-term",
    "test-params": {
        "records": [
          # Optional DMARC record object
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "aspf-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "raiolanetworks.com",
  "target-hostname": "ns-530.awsdns-02.net",
  "type": "DMARC",
  "test-name": "aspf-term",
  "test-params": {
      "records": [
        // Optional DMARC record object
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "raiolanetworks.com",
    "target-hostname": "ns-530.awsdns-02.net",
    "type": "DMARC",
    "test-name": "aspf-term",
    "test-params": {
        "records": [
            {
                "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
                "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
                "processed-correctly": true,
                "terms": {
                    "p": "reject",
                    "sp": "quarantine",
                    "pct": "100",
                    "rua": "mailto:dmarc@raiolanetworks.com",
                    "ruf": "mailto:dmarc@raiolanetworks.com",
                    "ri": "86400"
                }
            }
        ]
    }
}

Response

{
    "test-status": 1,
    "output-elements": [
        {
            "uuid": "b015432b-5d2c-4e8b-855b-6638ff56db48",
            "record": "v=DMARC1; p=reject; sp=quarantine; pct=100; rua=mailto:dmarc@raiolanetworks.com; ruf=mailto:dmarc@raiolanetworks.com; ri=86400",
            "processed-correctly": true,
            "terms": {
                "p": "reject",
                "sp": "quarantine",
                "pct": "100",
                "rua": "mailto:dmarc@raiolanetworks.com",
                "ruf": "mailto:dmarc@raiolanetworks.com",
                "ri": "86400"
            },
            "test-status": 1,
            "test-flags": {
                "no-has-aspf-and-use-default-value": true,
                "has-aspf-with-r-value": false,
                "has-aspf-with-s-value": false
            },
            "test-warning-messages": []
        }
    ],
    "test-successful-messages": [
        "The term is not explicitly defined, so it takes the default value 'r'. SPF validation accepts emails from the domain and subdomains"
    ],
    "test-warning-messages": [],
    "test-info-messages": []
}

Slug: aspf-term

Description

The 'aspf' term in a DMARC record specifies the DKIM validation alignment, in other words, how SPF validation is done.

Values:

r: (default) SPF validation supports mails from domain and subdomains.
s: SPF validation supports mails only from domain not from subdomains.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<DMARC>`	No	DMARC records of domain. Only should send one record.

The parameter "records" aren't mandatory, this parameter are a auto-recovery param, you can see the section of Auto-recovery of test params.

See the DMARC type to see the type of record that can be sent.

Cases

Case	Status	Description
Success	`1`	Term is undefined (default value) or has `r` value.
Warning	`0`	Has `s` value.
Fail	`-1`	Has an invalid value. Or has problems for process the DMARC record.

Output element test flags

Key	Description
no-has-aspf-and-use-default-value	The term 'aspf' is undefined and uses the default value (`r`).
has-aspf-with-r-value	The term has `r` value.
has-aspf-with-s-value	The term has `s` value.

CAA tests

Type: CAA

This section describes the tests of the CAA records.

Record has recommended TTL range test

curl -X POST 'https://intodns.io/api/v1/run-test' \
  -H 'X-Accept-Language: en' \
  -H 'Content-Type: application/json' \
  --data-raw '<json-parameters>'

$data = json_encode([
    "host" => "google.com",
    "target-hostname" => "ns2.google.com",
    "type" => "CAA",
    "test-name" => "records-has-recommended-ttl-range",
    "test-params" => [
        "records" => [
          // Optional CAA records objects
        ]
    ]
]);

$handler = curl_init('https://intodns.io/api/v1/run-test');
curl_setopt($handler, CURLOPT_RETURNTRANSFER, true);
curl_setopt($handler, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-Accept-Language: en'
]);
curl_setopt($handler, CURLOPT_POST, true);
curl_setopt($handler, CURLOPT_POSTFIELDS, $data);
$output = json_decode(curl_exec($handler));
curl_close($handler);

var_dump($output);

import http.client
import json

data = {
    "host": "google.com",
    "target-hostname": "ns2.google.com",
    "type": "CAA",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
          # Optional CAA records objects
        ]
    }
}

conn = http.client.HTTPSConnection("intodns.io")

conn.request("POST", "/api/v1/run-test", body=json.dumps(data), headers={
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
})

data = json.loads(conn.getresponse().read().decode("utf-8"))

conn.close()

print(data)

// Node

import https from 'https';

const data = JSON.stringify({
  "host": "google.com",
  "target-hostname": "ns2.google.com",
  "type": "CAA",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional CAA records objects
      ]
  }
});

const options = {
  hostname: 'intodns.io',
  path: '/api/v1/run-test',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(data),
    'X-Accept-Language': 'en'
  },
};

const request = https.request(options, (res) => {
  let buffer = '';
  res.on('data', chunk => buffer += chunk);
  res.on('end', () => {
    const data = JSON.parse(buffer);
    console.log(data);
  });
});

request.on('error', error => {console.error(error);});
request.write(data);
request.end();

// Browser

const data = JSON.stringify({
  "host": "google.com",
  "target-hostname": "ns2.google.com",
  "type": "CAA",
  "test-name": "records-has-recommended-ttl-range",
  "test-params": {
      "records": [
        // Optional CAA records objects
      ]
  }
});

fetch('https://intodns.io/api/v1/run-test', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'X-Accept-Language': 'en'
  },
  body: data
})
.then(response => response.json())
.then(data => {console.log(data);})
.catch(error => {console.error(error);});

Json parameters:

{
    "host": "google.com",
    "target-hostname": "ns2.google.com",
    "type": "CAA",
    "test-name": "records-has-recommended-ttl-range",
    "test-params": {
        "records": [
            {
                "host": "google.com",
                "type": "CAA",
                "value": "pki.goog",
                "ttl": 86400,
                "flags": 0,
                "tag": "issue",
                "uuid": "3d20f31a-aa78-4c2c-932c-3a16d806e896",
                "value-sentences": {
                    "domain": "pki.goog"
                }
            }
        ]
    }
}

Response

{
    "test-status": 0,
    "output-elements": [
        {
            "host": "google.com",
            "type": "CAA",
            "value": "pki.goog",
            "ttl": 86400,
            "flags": 0,
            "tag": "issue",
            "uuid": "5ed716f9-8765-47ec-8538-9a5f73289a10",
            "value-sentences": {
                "domain": "pki.goog"
            },
            "test-status": 0,
            "test-flags": {
                "has-recommended-ttl": false
            },
            "test-warning-messages": [
                "The record has a TTL out of the optimal range for its type"
            ]
        }
    ],
    "test-successful-messages": [],
    "test-warning-messages": [
        "The record pki.goog has a TTL out of the optimal range for its type"
    ],
    "test-info-messages": [
        "The optimal TTL range for the CAA records is ( 3600 \u2264  x \u2264 14400 )"
    ]
}

Slug: records-has-recommended-ttl-range

Description

The CAA records optimal range is ( 3600 ≤ x ≤ 14400 ), meaning between 1 hour and 4 hours.

Test parameters

Parameter	Type	Mandatory	Description
records	`array<CAA>`	No	CAA records of domain.

The parameter "records" isn't mandatory, this parameter is a auto-recovery param, you can see the section of Auto-recovery of test params.

See the CAA type to see the type of records that can be sent.

Cases

Case	Status	Description
Success	`1`	All records has optimal TTL.
Warning	`0`	Some records has optimal TTL, an others has recommended TTL but none is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).
Fail	`-1`	Some records is out of the recommended TTL range (or optimal TTL range if only has optimal TTL range).

Output element test flags

Key	Description
has-recommended-ttl	If affirmative, this flag indicates that the analysed record has a optimal or recommended TTL.