API reference›Mail Order Management APIs

Fetch Order Details

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

API to fetch detailed information about a specific Mail Order on Titan Mail Cloud Infra using the titanOrderId.

This API provides comprehensive details about a mail order including account counts, domain information, and order status.

Query parameters

titanOrderIdnumberrequired

The Titan order ID for which detailed information is required

Example: 123

Responses

200OKapplication/json

titanOrderIdnumber

The Titan order ID

Example: 123

domainNamestring

The mail order name associated to the Titan order ID

Example: abc.com

orderIdstring

The order ID stored on your end for this mail order, if any. You can use this data to correlate orders at your end and in Titan.

Example: 12431

planTypestring

The plan type of the mail order

Example: premium

noOfAccountsnumber

Maximum number of email accounts permitted to be created within the domain. E.g. The domain might have 3 mailboxes created with a limit of 10 mailboxes. The return value will be 10 in this case

Example: 10

noOfBillableAccountsnumber

Number of email accounts provisioned, which are in active/suspended state if domain is on non paid plan. Would be equal to noOfAccounts for paid domains.

Example: 10

noOfActiveAccountsnumber

Number of active email accounts

Example: 6

noOfProvisionedAccountsnumber

Number of email accounts provisioned, which are in active/suspended state

Example: 8

expiryDatestring

In yyyy-MM-dd format. Expiry date set against the domain

Example: 2020-01-31

statusstring

Current status of the order

Example: active

customerEmailAddressstring

Customer email address All communications will be sent here This will also be the primary admin for the domain

Example: titanuser@titan.mail

serverHostNamestringoptional

hostname of the hosting-server where user's hosting order has been provisioned. only available in case provisioning is via cPanel/plesk plugin

Example: cpanel102.titan.co

sourcestring · enumoptional

The source from which the order is received - Refers to the kind of package provisioned on the partners end. Source field should be either of these values - domain, standalone, hosting, migrated. It will be validated against these values when the Api call is made

Example: hosting

Possible values: domain standalone hosting migrated

titanCustomerIdnumber

Titan's internal customer ID

Example: 456

customerIdstring

Partner's customer ID stored on your end for this customer

Example: abc123

addonSubscriptionCountersobjectoptional

Map of addon type to the configured subscription quota for this order.

Example: {"storage_addon":5}

Show propertiesHide properties

addonTypenumberoptionaladditional property

400InvalidParameter

titanOrderId is not provided or is invalid

403FORBIDDEN

Partner does not have access to the specified order

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

GET/partner/fetchOrderDetails

#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/fetchOrderDetails?titanOrderId=123");

  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/fetchOrderDetails?titanOrderId=123");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");

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

var client = new RestClient("https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123");
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/fetchOrderDetails" {:headers {:Authorization "API.Key"}
                                                                 :query-params {:titanOrderId "123"}})

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/fetchOrderDetails?titanOrderId=123'), headers: headers);
  print(response.body);
}

let httpRequestMessage = new HttpRequestMessage(
  HttpMethod("GET"),
  new Uri("https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123")
)

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/fetchOrderDetails?titanOrderId=123"

	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/fetchOrderDetails?titanOrderId=123 HTTP/1.1
Host: bll.titan.email
Authorization: API.Key

GET /bll/partner/fetchOrderDetails?titanOrderId=123 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/fetchOrderDetails?titanOrderId=123")
    .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/fetchOrderDetails?titanOrderId=123"))
  .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/fetchOrderDetails?titanOrderId=123")
  .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/fetchOrderDetails?titanOrderId=123")
  .header("Authorization", "API.Key")
  .asString();
System.out.println(response.getBody());

fetch('https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123', {
  headers: {
    Authorization: 'API.Key'
  }
})

import axios from 'axios'

const options = {
  method: 'GET',
  url: 'https://bll.titan.email/partner/fetchOrderDetails',
  params: {
    titanOrderId: '123'
  },
  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/fetchOrderDetails', {
  query: {
    titanOrderId: '123'
  },
  headers: {
    Authorization: 'API.Key'
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123",
  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/fetchOrderDetails?titanOrderId=123");
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/fetchOrderDetails",
    ["Authorization" => "API.Key"];
    query = ["titanOrderId" => "123"]
)

println(String(response.body))

val client = OkHttpClient()

val request = Request.Builder()
  .url("https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123")
  .get()
  .addHeader("Authorization", "API.Key")
  .build()

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

fetch('https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123', {
  headers: {
    Authorization: 'API.Key'
  }
})

import axios from 'axios'

const options = {
  method: 'GET',
  url: 'https://bll.titan.email/partner/fetchOrderDetails',
  params: {
    titanOrderId: '123'
  },
  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/fetchOrderDetails', {
  query: {
    titanOrderId: '123'
  },
  headers: {
    Authorization: 'API.Key'
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123', {
  headers: {
    Authorization: 'API.Key'
  }
})

#import <Foundation/Foundation.h>

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123"]
                                                      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/fetchOrderDetails?titanOrderId=123" 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/fetchOrderDetails?titanOrderId=123");

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/fetchOrderDetails', [
  'headers' => [
    'Authorization' => 'API.Key'
  ],
  'query' => [
    'titanOrderId' => '123'
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key'
])
  ->get('https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123');

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

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123' -Method 'GET' -Headers $headers
$response

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

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123' -Method 'GET' -Headers $headers
$response

import http.client

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

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

conn.request(
    "GET",
    "/partner/fetchOrderDetails?titanOrderId=123",
    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/fetchOrderDetails?titanOrderId=123",
    headers=headers,
)

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

conn.close()

requests.get(
    "https://bll.titan.email/partner/fetchOrderDetails",
    headers={
      "Authorization": "API.Key"
    },
    params={
      "titanOrderId": "123"
    }
)

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

httpx.get(
    "https://bll.titan.email/partner/fetchOrderDetails",
    headers={
      "Authorization": "API.Key"
    },
    params={
      "titanOrderId": "123"
    }
)

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

library(httr2)

response <- request("https://bll.titan.email/partner/fetchOrderDetails") |>
  req_headers("Authorization" = "API.Key") |>
  req_url_query("titanOrderId" = "123") |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

url = URI("https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123")

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/fetchOrderDetails?titanOrderId=123")
    .header("Authorization", "API.Key");

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

curl 'https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123' \
  --header 'Authorization: API.Key'

wget --quiet \
  --method GET \
  --header 'Authorization: API.Key' \
  --output-document \
  - 'https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123'

http --ignore-stdin 'GET' 'https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123' \
  'Authorization:API.Key'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/fetchOrderDetails?titanOrderId=123")!)
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

{
  "titanOrderId": 123,
  "domainName": "abc.com",
  "orderId": "12431",
  "planType": "premium",
  "noOfAccounts": 10,
  "noOfBillableAccounts": 10,
  "noOfActiveAccounts": 6,
  "noOfProvisionedAccounts": 8,
  "expiryDate": "2020-01-31",
  "status": "active",
  "customerEmailAddress": "titanuser@titan.mail",
  "serverHostName": "cpanel102.titan.co",
  "source": "hosting",
  "titanCustomerId": 456,
  "customerId": "abc123",
  "addonSubscriptionCounters": {
    "storage_addon": 5
  }
}