API reference›Mail Order Management APIs

Toggle Mail Service

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

This API is relevant if you are using Titan's cPanel plugin.
Using this api, You can choose to move all domains from Titan cloud to cPanel local (or vice versa) for a particular cPanel account. Calling this api would result in deleting all the existing domain orders within that cPanel account and recreating them with the selected mail service. The action will be applied to all existing domains and all future domains added within the cPanel account. All domains in a cPanel account can either be on local or titan at a given point in time. This will not result in any migration of email accounts, email data or dns; those will need to be handled by you separately.

Body

application/json

titanOrderIdnumberrequired

The unique order ID against each domain provisioned with Titan

Example: 1

mailServicestring · enumrequired

Desired mail service to which customer wants to move

Example: titan

Possible values: titan local

modestring · enumoptional

toggling strategy, default is all_domains

Example: all_domains

Possible values: single_domain all_domains

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

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

POST/partner/toggleMailService

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

  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"
    "  \"mailService\": \"titan\",\n"
    "  \"mode\": \"all_domains\"\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/toggleMailService");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");
request.Content = new StringContent(
"""
{
  "titanOrderId": 1,
  "mailService": "titan",
  "mode": "all_domains"
}
""",
System.Text.Encoding.UTF8, "application/json");

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

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

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

(client/post "https://bll.titan.email/partner/toggleMailService" {:headers {:Authorization "API.Key"}
                                                                  :content-type :json
                                                                  :form-params {:titanOrderId 1
                                                                                :mailService "titan"
                                                                                :mode "all_domains"}})

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,"mailService":"titan","mode":"all_domains"}';

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

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

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

let content = new StringContent("""{
  "titanOrderId": 1,
  "mailService": "titan",
  "mode": "all_domains"
}""", 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/toggleMailService"

	payload := strings.NewReader(`{
  "titanOrderId": 1,
  "mailService": "titan",
  "mode": "all_domains"
}`)

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

{"titanOrderId":1,"mailService":"titan","mode":"all_domains"}

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

{"titanOrderId":1,"mailService":"titan","mode":"all_domains"}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1,\"mailService\":\"titan\",\"mode\":\"all_domains\"}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("POST", "https://bll.titan.email/partner/toggleMailService")
    .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,\"mailService\":\"titan\",\"mode\":\"all_domains\"}".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/toggleMailService"))
  .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,\"mailService\":\"titan\",\"mode\":\"all_domains\"}");

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/toggleMailService")
  .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,\"mailService\":\"titan\",\"mode\":\"all_domains\"}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

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

fetch('https://bll.titan.email/partner/toggleMailService', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/toggleMailService',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  }
}

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/toggleMailService', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  }
})

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

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://bll.titan.email/partner/toggleMailService");
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,\"mailService\":\"titan\",\"mode\":\"all_domains\"}");

using HTTP
using JSON

response = HTTP.post(
    "https://bll.titan.email/partner/toggleMailService",
    [
        "Authorization" => "API.Key",
        "Content-Type" => "application/json"
    ],
    JSON.json(Dict(
        "titanOrderId" => 1,
        "mailService" => "titan",
        "mode" => "all_domains"
    ))
)

println(String(response.body))

val client = OkHttpClient()

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

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

fetch('https://bll.titan.email/partner/toggleMailService', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/toggleMailService',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  }
}

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/toggleMailService', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/toggleMailService', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    mailService: 'titan',
    mode: 'all_domains'
  })
})

#import <Foundation/Foundation.h>

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

NSDictionary *parameters = @{ @"titanOrderId": @1,
                              @"mailService": @"titan",
                              @"mode": @"all_domains" };

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

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

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,
  'mailService' => 'titan',
  'mode' => 'all_domains'
]));

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

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

use Illuminate\Support\Facades\Http;

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

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

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

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/toggleMailService' -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,"mailService":"titan","mode":"all_domains"}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/toggleMailService' -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,
  "mailService": "titan",
  "mode": "all_domains"
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/partner/toggleMailService",
    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,
  "mailService": "titan",
  "mode": "all_domains"
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

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

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

conn.close()

requests.post(
    "https://bll.titan.email/partner/toggleMailService",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "mailService": "titan",
      "mode": "all_domains"
    }
)

async with aiohttp.ClientSession() as session:
    await session.post(
        "https://bll.titan.email/partner/toggleMailService",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "mailService": "titan",
          "mode": "all_domains"
        }
    )

httpx.post(
    "https://bll.titan.email/partner/toggleMailService",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "mailService": "titan",
      "mode": "all_domains"
    }
)

async with httpx.AsyncClient() as client:
    await client.post(
        "https://bll.titan.email/partner/toggleMailService",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "mailService": "titan",
          "mode": "all_domains"
        }
    )

library(httr2)

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

resp_body_string(response)

require 'uri'
require 'net/http'

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

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,
  "mailService": "titan",
  "mode": "all_domains"
}
JSON

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

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

let request = client
    .post("https://bll.titan.email/partner/toggleMailService")
    .header("Authorization", "API.Key")
    .header("Content-Type", "application/json")
    .json(&serde_json::json!({
        "titanOrderId": 1,
        "mailService": "titan",
        "mode": "all_domains"
    }));

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

curl https://bll.titan.email/partner/toggleMailService \
  --request POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --data '{
  "titanOrderId": 1,
  "mailService": "titan",
  "mode": "all_domains"
}'

wget --quiet \
  --method POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --body-data '{
  "titanOrderId": 1,
  "mailService": "titan",
  "mode": "all_domains"
}' \
  --output-document \
  - https://bll.titan.email/partner/toggleMailService

http --ignore-stdin 'POST' 'https://bll.titan.email/partner/toggleMailService' \
  'Authorization:API.Key' \
  'Content-Type:application/json' \
  --raw='{"titanOrderId":1,"mailService":"titan","mode":"all_domains"}'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/toggleMailService")!)
request.httpMethod = "POST"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let jsonBody = #"""
{
  "titanOrderId": 1,
  "mailService": "titan",
  "mode": "all_domains"
}
"""#
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"
}