API reference›Mail Order Management APIs

DNS Verification

POSThttps://bll.titan.email/partner/dnsLookup

API used to check whether a mail order has been verified with the correct MX/SPF records. Titan checks for MX/SPF verification in following cases:

Once order is created, records are checked automatically once on the same day(after few hours) and once on the next day.
On accessing Titan Control panel, records are checked automatically to show missing records info to the user. Records are rechecked in case user clicks on 'Check again' option in Titan Control panel.

Body

application/json

titanOrderIdnumberrequired

The unique order ID against each domain provisioned with Titan

Example: 1

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

domainExistsboolean

Returns true if the domain is registered and false if the domain does not exist

Example: true

nsRecordsstring[]

Returns the Nameservers currently setup against the domain

spfRecordsstring[]

mxRecordsstring[]

mxVerifiedboolean

Provides a True or False value on whether the MX records are correctly setup

Example: true

spfVerifiedboolean

Provides a True or False value on whether the SPF records are correctly setup

Example: true

lenientSPFboolean

Provides a True or False value on whether the domain is permitted to send/receive email with the incorrect SPF records

Example: true

400BAD_REQUEST

Domain exists in deleted or pending state in titan infra. "desc" will include information for failure.

See General Errors for other errors that this API can return.

POST/partner/dnsLookup

#include <curl/curl.h>

int main(void) {
  curl_global_init(CURL_GLOBAL_DEFAULT);
  CURL *curl = curl_easy_init();
  if (!curl) {
    curl_global_cleanup();
    return 1;
  }

  curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "POST");
  curl_easy_setopt(curl, CURLOPT_URL, "https://bll.titan.email/partner/dnsLookup");

  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, "Authorization: API.Key");
  headers = curl_slist_append(headers, "Content-Type: application/json");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

  curl_easy_setopt(curl, CURLOPT_POSTFIELDS,
    "{\n"
    "  \"titanOrderId\": 1\n"
    "}");

  CURLcode res = curl_easy_perform(curl);
  curl_easy_cleanup(curl);
  curl_slist_free_all(headers);
  curl_global_cleanup();

  return (int)res;
}

using var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "https://bll.titan.email/partner/dnsLookup");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");
request.Content = new StringContent(
"""
{
  "titanOrderId": 1
}
""",
System.Text.Encoding.UTF8, "application/json");

using var response = await client.SendAsync(request);

var client = new RestClient("https://bll.titan.email/partner/dnsLookup");
var request = new RestRequest("", Method.Post);
request.AddHeader("Authorization", "API.Key");
request.AddHeader("Content-Type", "application/json");
request.AddStringBody("""
{
  "titanOrderId": 1
}
""", ContentType.Json);
var response = await client.ExecuteAsync(request);

(require '[clj-http.client :as client])

(client/post "https://bll.titan.email/partner/dnsLookup" {:headers {:Authorization "API.Key"}
                                                          :content-type :json
                                                          :form-params {:titanOrderId 1}})

import 'package:http/http.dart' as http;

void main() async {
  final headers = <String,String>{
    'Authorization': 'API.Key',
    'Content-Type': 'application/json',
  };

  final body = r'{"titanOrderId":1}';

  final response = await http.post(Uri.parse('https://bll.titan.email/partner/dnsLookup'), headers: headers, body: body);
  print(response.body);
}

let httpRequestMessage = new HttpRequestMessage(
  HttpMethod("POST"),
  new Uri("https://bll.titan.email/partner/dnsLookup")
)

httpRequestMessage.Headers.Add("Authorization", "API.Key")
httpRequestMessage.Headers.Add("Content-Type", "application/json")

let content = new StringContent("""{
  "titanOrderId": 1
}""", Encoding.UTF8, "application/json")
httpRequestMessage.Content <- content

let client = new HttpClient()
let! result = client.SendAsync(httpRequestMessage)

package main

import (
	"fmt"
	"io"
	"net/http"
	"strings"
)

func main() {
	requestUrl := "https://bll.titan.email/partner/dnsLookup"

	payload := strings.NewReader(`{
  "titanOrderId": 1
}`)

	req, _ := http.NewRequest("POST", requestUrl, payload)

	req.Header.Add("Authorization", "API.Key")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /partner/dnsLookup HTTP/1.1
Host: bll.titan.email
Authorization: API.Key
Content-Type: application/json

{"titanOrderId":1}

POST /bll/partner/dnsLookup HTTP/1.1
Host: api-euc1.titan.email
Authorization: API.Key
Content-Type: application/json

{"titanOrderId":1}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("POST", "https://bll.titan.email/partner/dnsLookup")
    .addHeader("Authorization", "API.Key")
    .addHeader("Content-Type", "application/json")
    .setBody(body.toByteArray())
    .execute()
    .get();
  System.out.println(response.getResponseBody());
}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(java.net.URI.create("https://bll.titan.email/partner/dnsLookup"))
  .header("Authorization", "API.Key")
  .header("Content-Type", "application/json")
  .method("POST", HttpRequest.BodyPublishers.ofByteArray(body.toByteArray()))
  .build();

HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

RequestBody body = RequestBody.create(MediaType.parse("application/json"), "{\"titanOrderId\":1}");

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/dnsLookup")
  .method("POST", body)
  .addHeader("Authorization", "API.Key")
  .addHeader("Content-Type", "application/json")
  .build();

try (Response response = client.newCall(request).execute()) {
  System.out.println(response.body().string());
}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

HttpResponse<String> response = Unirest.request("POST", "https://bll.titan.email/partner/dnsLookup")
  .header("Authorization", "API.Key")
  .header("Content-Type", "application/json")
  .body(body.toByteArray())
  .asString();
System.out.println(response.getBody());

fetch('https://bll.titan.email/partner/dnsLookup', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/dnsLookup',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1
  }
}

try {
  const { data } = await axios.request(options)
  console.log(data)
} catch (error) {
  console.error(error)
}

import { ofetch } from 'ofetch'

ofetch('https://bll.titan.email/partner/dnsLookup', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/dnsLookup",
  method: "POST",
  processData: false,
  contentType: false,
  beforeSend(xhr) {
    xhr.setRequestHeader("Authorization", "API.Key");
    xhr.setRequestHeader("Content-Type", "application/json");
  },
  data: "{\"titanOrderId\":1}"
}).done((response) => console.log(response));

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://bll.titan.email/partner/dnsLookup");
xhr.withCredentials = true;
xhr.setRequestHeader("Authorization", "API.Key");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.addEventListener("load", () => console.log(xhr.responseText));
xhr.send("{\"titanOrderId\":1}");

using HTTP
using JSON

response = HTTP.post(
    "https://bll.titan.email/partner/dnsLookup",
    [
        "Authorization" => "API.Key",
        "Content-Type" => "application/json"
    ],
    JSON.json(Dict("titanOrderId" => 1))
)

println(String(response.body))

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"titanOrderId\":1}")
val request = Request.Builder()
  .url("https://bll.titan.email/partner/dnsLookup")
  .post(body)
  .addHeader("Authorization", "API.Key")
  .addHeader("Content-Type", "application/json")
  .build()

val response = client.newCall(request).execute()

fetch('https://bll.titan.email/partner/dnsLookup', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/dnsLookup',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1
  }
}

try {
  const { data } = await axios.request(options)
  console.log(data)
} catch (error) {
  console.error(error)
}

import { ofetch } from 'ofetch'

ofetch('https://bll.titan.email/partner/dnsLookup', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/dnsLookup', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1
  })
})

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"Authorization": @"API.Key",
                           @"Content-Type": @"application/json" };

NSDictionary *parameters = @{ @"titanOrderId": @1 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/dnsLookup"]
                                                      cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                  timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
  if (error) {
    NSLog(@"%@", error);
  } else {
    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
    NSLog(@"%@", httpResponse);
  }
}];
[dataTask resume];

open Lwt.Infix

let () =
  Lwt_main.run (
    let uri = Uri.of_string "https://bll.titan.email/partner/dnsLookup" in
    let headers = Cohttp.Header.of_list [
      ("Authorization", "API.Key");
      ("Content-Type", "application/json");
    ] in
    let part0 = "{\"titanOrderId\":1}" in
    let body = Cohttp_lwt.Body.of_string (String.concat "" [part0]) in
    Cohttp_lwt_unix.Client.call ~headers ~body (Cohttp.Code.method_of_string "POST") uri
    >>= fun (_response, body) ->
    Cohttp_lwt.Body.to_string body >>= Lwt_io.printl
  )

$ch = curl_init("https://bll.titan.email/partner/dnsLookup");

curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['Authorization: API.Key', 'Content-Type: application/json']);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
  'titanOrderId' => 1
]));

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

$response = $client->request('POST', 'https://bll.titan.email/partner/dnsLookup', [
  'headers' => [
    'Authorization' => 'API.Key',
    'Content-Type' => 'application/json'
  ],
  'json' => [
    'titanOrderId' => 1
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key',
  'Content-Type' => 'application/json'
])
  ->post('https://bll.titan.email/partner/dnsLookup', [
    'titanOrderId' => 1
  ]);

$headers = @{
  'Authorization' = 'API.Key'
  'Content-Type' = 'application/json'
}

$body = [System.IO.MemoryStream]::new()
$bytes = [System.Text.Encoding]::UTF8.GetBytes('{"titanOrderId":1}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/dnsLookup' -Method 'POST' -Headers $headers -Body $body.ToArray()
$body.Dispose()
$response

$headers = @{
  'Authorization' = 'API.Key'
  'Content-Type' = 'application/json'
}

$body = [System.IO.MemoryStream]::new()
$bytes = [System.Text.Encoding]::UTF8.GetBytes('{"titanOrderId":1}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/dnsLookup' -Method 'POST' -Headers $headers -Body $body.ToArray()
$body.Dispose()
$response

import http.client
import json

conn = http.client.HTTPSConnection("bll.titan.email")

payload = json.dumps({
  "titanOrderId": 1
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/partner/dnsLookup",
    body=payload,
    headers=headers,
)

response = conn.getresponse()
print(response.read().decode())

conn.close()

import http.client
import json

conn = http.client.HTTPSConnection("api-euc1.titan.email")

payload = json.dumps({
  "titanOrderId": 1
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/bll/partner/dnsLookup",
    body=payload,
    headers=headers,
)

response = conn.getresponse()
print(response.read().decode())

conn.close()

requests.post(
    "https://bll.titan.email/partner/dnsLookup",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1
    }
)

async with aiohttp.ClientSession() as session:
    await session.post(
        "https://bll.titan.email/partner/dnsLookup",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1
        }
    )

httpx.post(
    "https://bll.titan.email/partner/dnsLookup",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1
    }
)

async with httpx.AsyncClient() as client:
    await client.post(
        "https://bll.titan.email/partner/dnsLookup",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1
        }
    )

library(httr2)

response <- request("https://bll.titan.email/partner/dnsLookup") |>
  req_method("POST") |>
  req_headers(
    "Authorization" = "API.Key",
    "Content-Type" = "application/json"
  ) |>
  req_body_json(list(
    titanOrderId = 1
  )) |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

url = URI("https://bll.titan.email/partner/dnsLookup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'API.Key'
request["Content-Type"] = 'application/json'
request.body = <<~JSON
{
  "titanOrderId": 1
}
JSON

response = http.request(request)
puts response.read_body

let client = reqwest::Client::new();

let request = client
    .post("https://bll.titan.email/partner/dnsLookup")
    .header("Authorization", "API.Key")
    .header("Content-Type", "application/json")
    .json(&serde_json::json!({
        "titanOrderId": 1
    }));

let response = request.send().await?;

curl https://bll.titan.email/partner/dnsLookup \
  --request POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --data '{
  "titanOrderId": 1
}'

wget --quiet \
  --method POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --body-data '{
  "titanOrderId": 1
}' \
  --output-document \
  - https://bll.titan.email/partner/dnsLookup

http --ignore-stdin 'POST' 'https://bll.titan.email/partner/dnsLookup' \
  'Authorization:API.Key' \
  'Content-Type:application/json' \
  --raw='{"titanOrderId":1}'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/dnsLookup")!)
request.httpMethod = "POST"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let jsonBody = #"""
{
  "titanOrderId": 1
}
"""#
request.httpBody = jsonBody.data(using: .utf8)

let (data, response) = try await URLSession.shared.data(for: request)

guard let httpResponse = response as? HTTPURLResponse,
      200..<300 ~= httpResponse.statusCode else {
  throw URLError(.badServerResponse)
}

print(String(data: data, encoding: .utf8) ?? "")

Response

{
  "reqID": "server.req.id",
  "domainExists": true,
  "nsRecords": [
    "string"
  ],
  "spfRecords": [
    "string"
  ],
  "mxRecords": [
    "string"
  ],
  "mxVerified": true,
  "spfVerified": true,
  "lenientSPF": true
}