API reference›Mail Order Management APIs

Check Mail Order Availability

GEThttps://bll.titan.email/partner/checkMailOrderAvailability

API to check a mail order with given domainName is available for provisioning on Titan

Availability behaviour

isAvailable: true — the domain is available for the requesting partner to create a mail order.
isAvailable: false — the requesting partner already has an order for this domain; its details are returned in the response (titanOrderId, customerDetails, orderDetails).
The same domain can have a mail order under multiple partners, but only one of those orders is serviceable at a time; the others are non-serviceable. Even when the domain is already serviceable under a different partner, this API returns true and the partner can still create an order — it is created in a non-serviceable state.
- Serviceable — all email services are allowed.
- Non-serviceable — email services are not allowed, but the user can still log in to their account.
To make the order serviceable, the user must prove ownership of the domain. Once ownership is verified, an automated status-switch job makes the order serviceable and moves the previously serviceable order to non-serviceable — no manual action is required.
Titan is updating its mail interfaces to guide users on how to prove domain ownership, making this state easier to understand.

Query parameters

domainNamestringrequired

name of domain

Example: domainname.com

Responses

200OKapplication/json

isAvailableboolean

true implies domain is available and can be provisioned, false implies domain name is already-in-use and a new order with the same name cannot be provisioned.

Example: true

titanOrderIdnumber

In case if the order using given domain name is provisioned by you, this will contain its titanOrderId. If not provisioned by you then this field will not be present.

Example: 1

customerDetailsobject

Details of associated customer

Show propertiesHide properties

titanCustomerIdnumber

unique customer id at Titan's end

Example: 123

customerIdstring

customer id at your end

Example: customer

customerEmailstring

customer email

Example: customer@domain.com

orderDetailsobject

Details of associated order

Show propertiesHide properties

noOfAccountsnumber

max account limit for the domain

Example: 1000

createdAtnumber

Creation timestamp in epoch milliseconds.

Example: 1645315200000

expiryDatestring

In yyyy-MM-dd format.

Example: 2022-02-20

planTypestring · enum

This is the Titan mail plan. This would vary based on the plans being positioned with the partner.

Example: pro

Possible values: free pro premium pro_trial premium_trial ultra ultra_trial

statusstring · enum

Example: active

Possible values: active pending suspended deleted

sourcestring

source provided while provisioning the domain

Example: source

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

GET/partner/checkMailOrderAvailability

#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, "GET");
  curl_easy_setopt(curl, CURLOPT_URL, "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com");

  struct curl_slist *headers = NULL;
  headers = curl_slist_append(headers, "Authorization: API.Key");
  curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

  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.Get, "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");

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

var client = new RestClient("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com");
var request = new RestRequest("", Method.Get);
request.AddHeader("Authorization", "API.Key");
var response = await client.ExecuteAsync(request);

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

(client/get "https://bll.titan.email/partner/checkMailOrderAvailability" {:headers {:Authorization "API.Key"}
                                                                          :query-params {:domainName "domainname.com"}})

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

void main() async {
  final headers = <String,String>{
    'Authorization': 'API.Key',
  };

  final response = await http.get(Uri.parse('https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com'), headers: headers);
  print(response.body);
}

let httpRequestMessage = new HttpRequestMessage(
  HttpMethod("GET"),
  new Uri("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")
)

httpRequestMessage.Headers.Add("Authorization", "API.Key")

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

package main

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

func main() {
	requestUrl := "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com"

	req, _ := http.NewRequest("GET", requestUrl, nil)

	req.Header.Add("Authorization", "API.Key")

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

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

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

}

GET /partner/checkMailOrderAvailability?domainName=domainname.com HTTP/1.1
Host: bll.titan.email
Authorization: API.Key

GET /bll/partner/checkMailOrderAvailability?domainName=domainname.com HTTP/1.1
Host: api-euc1.titan.email
Authorization: API.Key

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("GET", "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")
    .addHeader("Authorization", "API.Key")
    .execute()
    .get();
  System.out.println(response.getResponseBody());
}

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
  .uri(java.net.URI.create("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com"))
  .header("Authorization", "API.Key")
  .method("GET", HttpRequest.BodyPublishers.noBody())
  .build();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")
  .method("GET", null)
  .addHeader("Authorization", "API.Key")
  .build();

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

HttpResponse<String> response = Unirest.request("GET", "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")
  .header("Authorization", "API.Key")
  .asString();
System.out.println(response.getBody());

fetch('https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com', {
  headers: {
    Authorization: 'API.Key'
  }
})

import axios from 'axios'

const options = {
  method: 'GET',
  url: 'https://bll.titan.email/partner/checkMailOrderAvailability',
  params: {
    domainName: 'domainname.com'
  },
  headers: {
    Authorization: 'API.Key'
  }
}

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/checkMailOrderAvailability', {
  query: {
    domainName: 'domainname.com'
  },
  headers: {
    Authorization: 'API.Key'
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com",
  method: "GET",
  processData: false,
  contentType: false,
  beforeSend(xhr) {
    xhr.setRequestHeader("Authorization", "API.Key");
  },
  data: null
}).done((response) => console.log(response));

const xhr = new XMLHttpRequest();
xhr.open("GET", "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com");
xhr.withCredentials = true;
xhr.setRequestHeader("Authorization", "API.Key");
xhr.addEventListener("load", () => console.log(xhr.responseText));
xhr.send(null);

using HTTP

response = HTTP.get(
    "https://bll.titan.email/partner/checkMailOrderAvailability",
    ["Authorization" => "API.Key"];
    query = ["domainName" => "domainname.com"]
)

println(String(response.body))

val client = OkHttpClient()

val request = Request.Builder()
  .url("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")
  .get()
  .addHeader("Authorization", "API.Key")
  .build()

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

fetch('https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com', {
  headers: {
    Authorization: 'API.Key'
  }
})

import axios from 'axios'

const options = {
  method: 'GET',
  url: 'https://bll.titan.email/partner/checkMailOrderAvailability',
  params: {
    domainName: 'domainname.com'
  },
  headers: {
    Authorization: 'API.Key'
  }
}

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/checkMailOrderAvailability', {
  query: {
    domainName: 'domainname.com'
  },
  headers: {
    Authorization: 'API.Key'
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com', {
  headers: {
    Authorization: 'API.Key'
  }
})

#import <Foundation/Foundation.h>

NSDictionary *headers = @{ @"Authorization": @"API.Key" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com"]
                                                      cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                  timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/checkMailOrderAvailability?domainName=domainname.com" in
    let headers = Cohttp.Header.of_list [
      ("Authorization", "API.Key");
    ] in
    Cohttp_lwt_unix.Client.call ~headers (Cohttp.Code.method_of_string "GET") uri
    >>= fun (_response, body) ->
    Cohttp_lwt.Body.to_string body >>= Lwt_io.printl
  )

$ch = curl_init("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com");

curl_setopt($ch, CURLOPT_HTTPHEADER, ['Authorization: API.Key']);

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

$response = $client->request('GET', 'https://bll.titan.email/partner/checkMailOrderAvailability', [
  'headers' => [
    'Authorization' => 'API.Key'
  ],
  'query' => [
    'domainName' => 'domainname.com'
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key'
])
  ->get('https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com');

$headers = @{
  'Authorization' = 'API.Key'
}

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com' -Method 'GET' -Headers $headers
$response

$headers = @{
  'Authorization' = 'API.Key'
}

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com' -Method 'GET' -Headers $headers
$response

import http.client

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

headers = {
  "Authorization": "API.Key"
}

conn.request(
    "GET",
    "/partner/checkMailOrderAvailability?domainName=domainname.com",
    headers=headers,
)

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

conn.close()

import http.client

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

headers = {
  "Authorization": "API.Key"
}

conn.request(
    "GET",
    "/bll/partner/checkMailOrderAvailability?domainName=domainname.com",
    headers=headers,
)

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

conn.close()

requests.get(
    "https://bll.titan.email/partner/checkMailOrderAvailability",
    headers={
      "Authorization": "API.Key"
    },
    params={
      "domainName": "domainname.com"
    }
)

async with aiohttp.ClientSession() as session:
    await session.get(
        "https://bll.titan.email/partner/checkMailOrderAvailability",
        headers={
          "Authorization": "API.Key"
        },
        params={
          "domainName": "domainname.com"
        }
    )

httpx.get(
    "https://bll.titan.email/partner/checkMailOrderAvailability",
    headers={
      "Authorization": "API.Key"
    },
    params={
      "domainName": "domainname.com"
    }
)

async with httpx.AsyncClient() as client:
    await client.get(
        "https://bll.titan.email/partner/checkMailOrderAvailability",
        headers={
          "Authorization": "API.Key"
        },
        params={
          "domainName": "domainname.com"
        }
    )

library(httr2)

response <- request("https://bll.titan.email/partner/checkMailOrderAvailability") |>
  req_headers("Authorization" = "API.Key") |>
  req_url_query("domainName" = "domainname.com") |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

url = URI("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'API.Key'

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

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

let request = client
    .get("https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")
    .header("Authorization", "API.Key");

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

curl 'https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com' \
  --header 'Authorization: API.Key'

wget --quiet \
  --method GET \
  --header 'Authorization: API.Key' \
  --output-document \
  - 'https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com'

http --ignore-stdin 'GET' 'https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com' \
  'Authorization:API.Key'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/checkMailOrderAvailability?domainName=domainname.com")!)
request.httpMethod = "GET"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")

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

{
  "isAvailable": true,
  "titanOrderId": 1,
  "customerDetails": {
    "titanCustomerId": 123,
    "customerId": "customer",
    "customerEmail": "customer@domain.com"
  },
  "orderDetails": {
    "noOfAccounts": 1000,
    "createdAt": 1645315200000,
    "expiryDate": "2022-02-20",
    "planType": "pro",
    "status": "active",
    "source": "source"
  }
}