API reference›Email Account Management APIs

Check Email Account Reactivation Eligibility

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

API to check if deleted Email Account can be reactivated.

Query parameters

titanOrderIdnumberrequired

The unique Titan order Id

Example: 1

titanAccountIdnumberrequired

The unique Titan account Id

Example: 123

Responses

200OKapplication/json

reactivationAllowedboolean

Example: true

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. Domain should be active state. It should be greater than or equal to today's date. Present when reactivationAllowed is true and purgeAt is set or reactivationAllowed is not allowed due to account is purged.

Example: 2025-02-20

reasonstring · enum

This is an enum with values. This field will be present if reactivationAllowed is false

DOMAIN_INACTIVE: The mail order (domain) this account belongs to is not active or suspended
ANOTHER_ACCOUNT_ALREADY_EXISTS: Another account already exists with the same email address
ACCOUNT_NOT_IN_DELETED_STATE: The account is not in a deleted state
ACCOUNT_PURGED: The account's purge date has passed and it can no longer be recovered

Example: ANOTHER_ACCOUNT_ALREADY_EXISTS

Possible values: DOMAIN_INACTIVE ANOTHER_ACCOUNT_ALREADY_EXISTS ACCOUNT_NOT_IN_DELETED_STATE ACCOUNT_PURGED

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

GET/partner/checkEmailAccountReactivationEligibility

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

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

var client = new RestClient("https://bll.titan.email/partner/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility" {:headers {:Authorization "API.Key"}
                                                                                        :query-params {:titanOrderId "1"
                                                                                                       :titanAccountId "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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=123'), headers: headers);
  print(response.body);
}

let httpRequestMessage = new HttpRequestMessage(
  HttpMethod("GET"),
  new Uri("https://bll.titan.email/partner/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=123 HTTP/1.1
Host: bll.titan.email
Authorization: API.Key

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

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

import axios from 'axios'

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

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

println(String(response.body))

val client = OkHttpClient()

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

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

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

import axios from 'axios'

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

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility', [
  'headers' => [
    'Authorization' => 'API.Key'
  ],
  'query' => [
    'titanOrderId' => '1',
    'titanAccountId' => '123'
  ]
]);

use Illuminate\Support\Facades\Http;

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

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

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

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

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

import http.client

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

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

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

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

conn.close()

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

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

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

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

library(httr2)

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

resp_body_string(response)

require 'uri'
require 'net/http'

url = URI("https://bll.titan.email/partner/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=123")
    .header("Authorization", "API.Key");

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

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

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

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

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/checkEmailAccountReactivationEligibility?titanOrderId=1&titanAccountId=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

{
  "reactivationAllowed": true,
  "purgeAt": "2025-02-20",
  "reason": "ANOTHER_ACCOUNT_ALREADY_EXISTS"
}