API reference›Email Account Management APIs

Fetch Email Accounts Storage

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

API to batch-fetch storage usage (used and limit) for multiple email accounts under a single Mail Order on the Titan Mail Cloud infra, in a single call. Requested account IDs with no matching account are omitted from the response.

Body

application/json

titanOrderIdnumberrequired

The unique order ID against each domain provisioned with Titan

Example: 1

titanAccountIdsnumber[]required

The list of Titan mail account IDs (maximum 200) under the order for which storage usage is required.

Example: [123,124]

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

accountsobject[]

Show propertiesHide properties

titanAccountIdnumberrequired

The unique mail account ID against each email provisioned with Titan.

Example: 123

storageUsednumber

Storage currently used by the mailbox, in MB.

Example: 1234

storageLimitnumber

Total storage allotted to the mailbox, in MB.

Example: 5000

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

POST/partner/fetchEmailAccountsStorage

#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/fetchEmailAccountsStorage");

  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"
    "  \"titanAccountIds\": [\n"
    "    123,\n"
    "    124\n"
    "  ]\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/fetchEmailAccountsStorage");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");
request.Content = new StringContent(
"""
{
  "titanOrderId": 1,
  "titanAccountIds": [
    123,
    124
  ]
}
""",
System.Text.Encoding.UTF8, "application/json");

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

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

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

(client/post "https://bll.titan.email/partner/fetchEmailAccountsStorage" {:headers {:Authorization "API.Key"}
                                                                          :content-type :json
                                                                          :form-params {:titanOrderId 1
                                                                                        :titanAccountIds [123 124]}})

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,"titanAccountIds":[123,124]}';

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

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

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

let content = new StringContent("""{
  "titanOrderId": 1,
  "titanAccountIds": [
    123,
    124
  ]
}""", 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/fetchEmailAccountsStorage"

	payload := strings.NewReader(`{
  "titanOrderId": 1,
  "titanAccountIds": [
    123,
    124
  ]
}`)

	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/fetchEmailAccountsStorage HTTP/1.1
Host: bll.titan.email
Authorization: API.Key
Content-Type: application/json

{"titanOrderId":1,"titanAccountIds":[123,124]}

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

{"titanOrderId":1,"titanAccountIds":[123,124]}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1,\"titanAccountIds\":[123,124]}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("POST", "https://bll.titan.email/partner/fetchEmailAccountsStorage")
    .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,\"titanAccountIds\":[123,124]}".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/fetchEmailAccountsStorage"))
  .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,\"titanAccountIds\":[123,124]}");

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/fetchEmailAccountsStorage")
  .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,\"titanAccountIds\":[123,124]}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

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

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

import axios from 'axios'

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

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/fetchEmailAccountsStorage', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    titanAccountIds: [123, 124]
  }
})

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

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://bll.titan.email/partner/fetchEmailAccountsStorage");
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,\"titanAccountIds\":[123,124]}");

using HTTP
using JSON

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

println(String(response.body))

val client = OkHttpClient()

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

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

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

import axios from 'axios'

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

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/fetchEmailAccountsStorage', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    titanAccountIds: [123, 124]
  }
})

import { request } from 'undici'

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

#import <Foundation/Foundation.h>

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

NSDictionary *parameters = @{ @"titanOrderId": @1,
                              @"titanAccountIds": @[ @123, @124 ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/fetchEmailAccountsStorage"]
                                                      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/fetchEmailAccountsStorage" in
    let headers = Cohttp.Header.of_list [
      ("Authorization", "API.Key");
      ("Content-Type", "application/json");
    ] in
    let part0 = "{\"titanOrderId\":1,\"titanAccountIds\":[123,124]}" 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/fetchEmailAccountsStorage");

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,
  'titanAccountIds' => [
    123,
    124
  ]
]));

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

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

use Illuminate\Support\Facades\Http;

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

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

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

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/fetchEmailAccountsStorage' -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,"titanAccountIds":[123,124]}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/fetchEmailAccountsStorage' -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,
  "titanAccountIds": [
    123,
    124
  ]
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/partner/fetchEmailAccountsStorage",
    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,
  "titanAccountIds": [
    123,
    124
  ]
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

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

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

conn.close()

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

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

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

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

library(httr2)

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

resp_body_string(response)

require 'uri'
require 'net/http'

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

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,
  "titanAccountIds": [
    123,
    124
  ]
}
JSON

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

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

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

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

curl https://bll.titan.email/partner/fetchEmailAccountsStorage \
  --request POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --data '{
  "titanOrderId": 1,
  "titanAccountIds": [
    123,
    124
  ]
}'

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

http --ignore-stdin 'POST' 'https://bll.titan.email/partner/fetchEmailAccountsStorage' \
  'Authorization:API.Key' \
  'Content-Type:application/json' \
  --raw='{"titanOrderId":1,"titanAccountIds":[123,124]}'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/fetchEmailAccountsStorage")!)
request.httpMethod = "POST"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let jsonBody = #"""
{
  "titanOrderId": 1,
  "titanAccountIds": [
    123,
    124
  ]
}
"""#
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",
  "accounts": [
    {
      "titanAccountId": 123,
      "storageUsed": 1234,
      "storageLimit": 5000
    }
  ]
}