API reference›Email Account Management APIs

Get All Email Accounts

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

API to fetch list of email accounts for a Mail Order on Titan Mail Cloud Infra

Query parameters

titanOrderIdnumberrequired

The unique Titan order ID against which the domain is provisioned

Example: 1

includeDeletedAccountsbooleanoptional

If deleted accounts needs to be included. False by default.

Example: true

domainNamestringoptional

[Deprecated] The mail order name associated to the Titan order ID

Example: xyz.com

customerIdstringoptional

[Deprecated] unique id stored on your end for each customer

Example: abcd123

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

accountsobject[]

Show propertiesHide properties

domainNamestringoptional

The mail order name associated to the Titan order ID

Example: xyz.com

titanAccountIdnumberrequired

Unique account id at Titan's end

Example: 123

customerIdstringoptional

The customer ID associated to the Titan order ID

Example: qwe123

emailstring

The email address for which the details are being provided

namestring

This is the name of the user associated to the email account provided

firstNamestringoptional

The first name of the customer for whom the email address is being created.

Example: James

lastNamestringoptional

The last name of the customer for whom the email address is being created.

Example: Bond

alternateEmailAddressstring

Alternate email address associated to the email account provided

statusstring · enum

The current status of the email account.

Example: active

Possible values: active suspended deleted

storageUsednumber

storageLimitnumber

isAdminboolean

purgeAtstringoptional

In yyyy-MM-dd format. All the account data would be purged from Titan's system permanently on this date. Account is expected to be in the deleted state and not already purged.

Example: 2024-02-20

addonSubscriptionsobject[]

Show propertiesHide properties

typestring

Example: storage_addon, email_backup

400BAD_REQUEST

domain status is not in active or suspension state.

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

GET/partner/listEmailAccounts

#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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123");

  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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");

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

var client = new RestClient("https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123");
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/listEmailAccounts" {:headers {:Authorization "API.Key"}
                                                                 :query-params {:titanOrderId "1"
                                                                                :includeDeletedAccounts "true"
                                                                                :domainName "xyz.com"
                                                                                :customerId "abcd123"}})

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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123'), headers: headers);
  print(response.body);
}

let httpRequestMessage = new HttpRequestMessage(
  HttpMethod("GET"),
  new Uri("https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")
)

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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123"

	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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123 HTTP/1.1
Host: bll.titan.email
Authorization: API.Key

GET /bll/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123 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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")
    .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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123"))
  .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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")
  .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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")
  .header("Authorization", "API.Key")
  .asString();
System.out.println(response.getBody());

fetch('https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123', {
  headers: {
    Authorization: 'API.Key'
  }
})

import axios from 'axios'

const options = {
  method: 'GET',
  url: 'https://bll.titan.email/partner/listEmailAccounts',
  params: {
    titanOrderId: '1',
    includeDeletedAccounts: 'true',
    domainName: 'xyz.com',
    customerId: 'abcd123'
  },
  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/listEmailAccounts', {
  query: {
    titanOrderId: '1',
    includeDeletedAccounts: 'true',
    domainName: 'xyz.com',
    customerId: 'abcd123'
  },
  headers: {
    Authorization: 'API.Key'
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123",
  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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123");
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/listEmailAccounts",
    ["Authorization" => "API.Key"];
    query = [
        "titanOrderId" => "1",
        "includeDeletedAccounts" => "true",
        "domainName" => "xyz.com",
        "customerId" => "abcd123"
    ]
)

println(String(response.body))

val client = OkHttpClient()

val request = Request.Builder()
  .url("https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")
  .get()
  .addHeader("Authorization", "API.Key")
  .build()

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

fetch('https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123', {
  headers: {
    Authorization: 'API.Key'
  }
})

import axios from 'axios'

const options = {
  method: 'GET',
  url: 'https://bll.titan.email/partner/listEmailAccounts',
  params: {
    titanOrderId: '1',
    includeDeletedAccounts: 'true',
    domainName: 'xyz.com',
    customerId: 'abcd123'
  },
  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/listEmailAccounts', {
  query: {
    titanOrderId: '1',
    includeDeletedAccounts: 'true',
    domainName: 'xyz.com',
    customerId: 'abcd123'
  },
  headers: {
    Authorization: 'API.Key'
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123', {
  headers: {
    Authorization: 'API.Key'
  }
})

#import <Foundation/Foundation.h>

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123"]
                                                      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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123" 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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123");

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/listEmailAccounts', [
  'headers' => [
    'Authorization' => 'API.Key'
  ],
  'query' => [
    'titanOrderId' => '1',
    'includeDeletedAccounts' => 'true',
    'domainName' => 'xyz.com',
    'customerId' => 'abcd123'
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key'
])
  ->get('https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123');

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

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123' -Method 'GET' -Headers $headers
$response

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

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123' -Method 'GET' -Headers $headers
$response

import http.client

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

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

conn.request(
    "GET",
    "/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123",
    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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123",
    headers=headers,
)

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

conn.close()

requests.get(
    "https://bll.titan.email/partner/listEmailAccounts",
    headers={
      "Authorization": "API.Key"
    },
    params={
      "titanOrderId": "1",
      "includeDeletedAccounts": "true",
      "domainName": "xyz.com",
      "customerId": "abcd123"
    }
)

async with aiohttp.ClientSession() as session:
    await session.get(
        "https://bll.titan.email/partner/listEmailAccounts",
        headers={
          "Authorization": "API.Key"
        },
        params={
          "titanOrderId": "1",
          "includeDeletedAccounts": "true",
          "domainName": "xyz.com",
          "customerId": "abcd123"
        }
    )

httpx.get(
    "https://bll.titan.email/partner/listEmailAccounts",
    headers={
      "Authorization": "API.Key"
    },
    params={
      "titanOrderId": "1",
      "includeDeletedAccounts": "true",
      "domainName": "xyz.com",
      "customerId": "abcd123"
    }
)

async with httpx.AsyncClient() as client:
    await client.get(
        "https://bll.titan.email/partner/listEmailAccounts",
        headers={
          "Authorization": "API.Key"
        },
        params={
          "titanOrderId": "1",
          "includeDeletedAccounts": "true",
          "domainName": "xyz.com",
          "customerId": "abcd123"
        }
    )

library(httr2)

response <- request("https://bll.titan.email/partner/listEmailAccounts") |>
  req_headers("Authorization" = "API.Key") |>
  req_url_query(
    "titanOrderId" = "1",
    "includeDeletedAccounts" = "true",
    "domainName" = "xyz.com",
    "customerId" = "abcd123"
  ) |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

url = URI("https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")

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/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")
    .header("Authorization", "API.Key");

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

curl 'https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123' \
  --header 'Authorization: API.Key'

wget --quiet \
  --method GET \
  --header 'Authorization: API.Key' \
  --output-document \
  - 'https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123'

http --ignore-stdin 'GET' 'https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123' \
  'Authorization:API.Key'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/listEmailAccounts?titanOrderId=1&includeDeletedAccounts=true&domainName=xyz.com&customerId=abcd123")!)
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

{
  "reqID": "server.req.id",
  "accounts": [
    {
      "domainName": "xyz.com",
      "titanAccountId": 123,
      "customerId": "qwe123",
      "email": "string",
      "name": "string",
      "firstName": "James",
      "lastName": "Bond",
      "alternateEmailAddress": "string",
      "status": "active",
      "storageUsed": 0,
      "storageLimit": 0,
      "isAdmin": true,
      "purgeAt": "2024-02-20",
      "addonSubscriptions": [
        {
          "type": "storage_addon, email_backup"
        }
      ]
    }
  ]
}