API reference›Email Account Management APIs

Create Email Account

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

API to create an email account for a Mail Order on the Titan Mail Cloud infra

Body

application/json

titanOrderIdnumberrequired

The unique order ID against each domain provisioned with Titan

Example: 1

orderIdstring

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

Example: partner.order.id

emailstringrequired

Email account to be created within Titanmail.

Example: james@xyz.com

namestringoptional

The name of the customer for whom the email address is being created. This is used if firstName and lastName are not provided.

Example: James Bond

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

alternateEmailAddressstringoptional

Alternate email address on which the customer can be contacted

Example: james@gmail.com

passwordstringoptional

Password to be set for the email account entered by end customer on partner website

Example: qwe123

requireAutoLoginTokenbooleanoptional

Partner specifies whether they need an auto login token.

Example: true

isAdminbooleanoptional

Specifies whether or not the user is an admin

Example: true

sendWelcomeEmailbooleanoptional

Specifies whether or not to send email to customer for this newly created email-account. Default value of this flag is false

Example: true

localestringoptional

Example: en-gb

sourcestringoptional

Example: standalone

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

titanAccountIdnumberrequired

The unique mail account ID against each email provisioned with Titan

Example: 1

webmailAutoLoginTokenstring

Response from Titans end. Titan passes you a short term auto login token to redirect customer to Titanmail. Check here to see How to use this token

Example: adfadfweqwe

400MAX_POP_ACCOUNT_LIMIT_REACHED

unable create account, when tries to create account but domain has N active account and plan only allows N active accounts.

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

POST/partner/createEmailAccount

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

  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"
    "  \"orderId\": \"partner.order.id\",\n"
    "  \"email\": \"james@xyz.com\",\n"
    "  \"name\": \"James Bond\",\n"
    "  \"firstName\": \"James\",\n"
    "  \"lastName\": \"Bond\",\n"
    "  \"alternateEmailAddress\": \"james@gmail.com\",\n"
    "  \"password\": \"qwe123\",\n"
    "  \"requireAutoLoginToken\": true,\n"
    "  \"isAdmin\": true,\n"
    "  \"sendWelcomeEmail\": true,\n"
    "  \"locale\": \"en-gb\",\n"
    "  \"source\": \"standalone\"\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/createEmailAccount");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");
request.Content = new StringContent(
"""
{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}
""",
System.Text.Encoding.UTF8, "application/json");

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

var client = new RestClient("https://bll.titan.email/partner/createEmailAccount");
var request = new RestRequest("", Method.Post);
request.AddHeader("Authorization", "API.Key");
request.AddHeader("Content-Type", "application/json");
request.AddStringBody("""
{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}
""", ContentType.Json);
var response = await client.ExecuteAsync(request);

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

(client/post "https://bll.titan.email/partner/createEmailAccount" {:headers {:Authorization "API.Key"}
                                                                   :content-type :json
                                                                   :form-params {:titanOrderId 1
                                                                                 :orderId "partner.order.id"
                                                                                 :email "james@xyz.com"
                                                                                 :name "James Bond"
                                                                                 :firstName "James"
                                                                                 :lastName "Bond"
                                                                                 :alternateEmailAddress "james@gmail.com"
                                                                                 :password "qwe123"
                                                                                 :requireAutoLoginToken true
                                                                                 :isAdmin true
                                                                                 :sendWelcomeEmail true
                                                                                 :locale "en-gb"
                                                                                 :source "standalone"}})

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,"orderId":"partner.order.id","email":"james@xyz.com","name":"James Bond","firstName":"James","lastName":"Bond","alternateEmailAddress":"james@gmail.com","password":"qwe123","requireAutoLoginToken":true,"isAdmin":true,"sendWelcomeEmail":true,"locale":"en-gb","source":"standalone"}';

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

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

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

let content = new StringContent("""{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}""", 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/createEmailAccount"

	payload := strings.NewReader(`{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}`)

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

{"titanOrderId":1,"orderId":"partner.order.id","email":"james@xyz.com","name":"James Bond","firstName":"James","lastName":"Bond","alternateEmailAddress":"james@gmail.com","password":"qwe123","requireAutoLoginToken":true,"isAdmin":true,"sendWelcomeEmail":true,"locale":"en-gb","source":"standalone"}

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

{"titanOrderId":1,"orderId":"partner.order.id","email":"james@xyz.com","name":"James Bond","firstName":"James","lastName":"Bond","alternateEmailAddress":"james@gmail.com","password":"qwe123","requireAutoLoginToken":true,"isAdmin":true,"sendWelcomeEmail":true,"locale":"en-gb","source":"standalone"}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("POST", "https://bll.titan.email/partner/createEmailAccount")
    .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,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}".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/createEmailAccount"))
  .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,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}");

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/createEmailAccount")
  .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,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

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

fetch('https://bll.titan.email/partner/createEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/createEmailAccount',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  }
}

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/createEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/createEmailAccount",
  method: "POST",
  processData: false,
  contentType: false,
  beforeSend(xhr) {
    xhr.setRequestHeader("Authorization", "API.Key");
    xhr.setRequestHeader("Content-Type", "application/json");
  },
  data: "{\"titanOrderId\":1,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}"
}).done((response) => console.log(response));

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://bll.titan.email/partner/createEmailAccount");
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,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}");

using HTTP
using JSON

response = HTTP.post(
    "https://bll.titan.email/partner/createEmailAccount",
    [
        "Authorization" => "API.Key",
        "Content-Type" => "application/json"
    ],
    JSON.json(Dict(
        "titanOrderId" => 1,
        "orderId" => "partner.order.id",
        "email" => "james@xyz.com",
        "name" => "James Bond",
        "firstName" => "James",
        "lastName" => "Bond",
        "alternateEmailAddress" => "james@gmail.com",
        "password" => "qwe123",
        "requireAutoLoginToken" => true,
        "isAdmin" => true,
        "sendWelcomeEmail" => true,
        "locale" => "en-gb",
        "source" => "standalone"
    ))
)

println(String(response.body))

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"titanOrderId\":1,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}")
val request = Request.Builder()
  .url("https://bll.titan.email/partner/createEmailAccount")
  .post(body)
  .addHeader("Authorization", "API.Key")
  .addHeader("Content-Type", "application/json")
  .build()

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

fetch('https://bll.titan.email/partner/createEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/createEmailAccount',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  }
}

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/createEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/createEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    orderId: 'partner.order.id',
    email: 'james@xyz.com',
    name: 'James Bond',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'james@gmail.com',
    password: 'qwe123',
    requireAutoLoginToken: true,
    isAdmin: true,
    sendWelcomeEmail: true,
    locale: 'en-gb',
    source: 'standalone'
  })
})

#import <Foundation/Foundation.h>

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

NSDictionary *parameters = @{ @"titanOrderId": @1,
                              @"orderId": @"partner.order.id",
                              @"email": @"james@xyz.com",
                              @"name": @"James Bond",
                              @"firstName": @"James",
                              @"lastName": @"Bond",
                              @"alternateEmailAddress": @"james@gmail.com",
                              @"password": @"qwe123",
                              @"requireAutoLoginToken": @YES,
                              @"isAdmin": @YES,
                              @"sendWelcomeEmail": @YES,
                              @"locale": @"en-gb",
                              @"source": @"standalone" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/createEmailAccount"]
                                                      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/createEmailAccount" in
    let headers = Cohttp.Header.of_list [
      ("Authorization", "API.Key");
      ("Content-Type", "application/json");
    ] in
    let part0 = "{\"titanOrderId\":1,\"orderId\":\"partner.order.id\",\"email\":\"james@xyz.com\",\"name\":\"James Bond\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"james@gmail.com\",\"password\":\"qwe123\",\"requireAutoLoginToken\":true,\"isAdmin\":true,\"sendWelcomeEmail\":true,\"locale\":\"en-gb\",\"source\":\"standalone\"}" 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/createEmailAccount");

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,
  'orderId' => 'partner.order.id',
  'email' => 'james@xyz.com',
  'name' => 'James Bond',
  'firstName' => 'James',
  'lastName' => 'Bond',
  'alternateEmailAddress' => 'james@gmail.com',
  'password' => 'qwe123',
  'requireAutoLoginToken' => true,
  'isAdmin' => true,
  'sendWelcomeEmail' => true,
  'locale' => 'en-gb',
  'source' => 'standalone'
]));

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

$response = $client->request('POST', 'https://bll.titan.email/partner/createEmailAccount', [
  'headers' => [
    'Authorization' => 'API.Key',
    'Content-Type' => 'application/json'
  ],
  'json' => [
    'titanOrderId' => 1,
    'orderId' => 'partner.order.id',
    'email' => 'james@xyz.com',
    'name' => 'James Bond',
    'firstName' => 'James',
    'lastName' => 'Bond',
    'alternateEmailAddress' => 'james@gmail.com',
    'password' => 'qwe123',
    'requireAutoLoginToken' => true,
    'isAdmin' => true,
    'sendWelcomeEmail' => true,
    'locale' => 'en-gb',
    'source' => 'standalone'
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key',
  'Content-Type' => 'application/json'
])
  ->post('https://bll.titan.email/partner/createEmailAccount', [
    'titanOrderId' => 1,
    'orderId' => 'partner.order.id',
    'email' => 'james@xyz.com',
    'name' => 'James Bond',
    'firstName' => 'James',
    'lastName' => 'Bond',
    'alternateEmailAddress' => 'james@gmail.com',
    'password' => 'qwe123',
    'requireAutoLoginToken' => true,
    'isAdmin' => true,
    'sendWelcomeEmail' => true,
    'locale' => 'en-gb',
    'source' => 'standalone'
  ]);

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

$body = [System.IO.MemoryStream]::new()
$bytes = [System.Text.Encoding]::UTF8.GetBytes('{"titanOrderId":1,"orderId":"partner.order.id","email":"james@xyz.com","name":"James Bond","firstName":"James","lastName":"Bond","alternateEmailAddress":"james@gmail.com","password":"qwe123","requireAutoLoginToken":true,"isAdmin":true,"sendWelcomeEmail":true,"locale":"en-gb","source":"standalone"}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/createEmailAccount' -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,"orderId":"partner.order.id","email":"james@xyz.com","name":"James Bond","firstName":"James","lastName":"Bond","alternateEmailAddress":"james@gmail.com","password":"qwe123","requireAutoLoginToken":true,"isAdmin":true,"sendWelcomeEmail":true,"locale":"en-gb","source":"standalone"}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/createEmailAccount' -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,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": True,
  "isAdmin": True,
  "sendWelcomeEmail": True,
  "locale": "en-gb",
  "source": "standalone"
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/partner/createEmailAccount",
    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,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": True,
  "isAdmin": True,
  "sendWelcomeEmail": True,
  "locale": "en-gb",
  "source": "standalone"
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

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

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

conn.close()

requests.post(
    "https://bll.titan.email/partner/createEmailAccount",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "orderId": "partner.order.id",
      "email": "james@xyz.com",
      "name": "James Bond",
      "firstName": "James",
      "lastName": "Bond",
      "alternateEmailAddress": "james@gmail.com",
      "password": "qwe123",
      "requireAutoLoginToken": True,
      "isAdmin": True,
      "sendWelcomeEmail": True,
      "locale": "en-gb",
      "source": "standalone"
    }
)

async with aiohttp.ClientSession() as session:
    await session.post(
        "https://bll.titan.email/partner/createEmailAccount",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "orderId": "partner.order.id",
          "email": "james@xyz.com",
          "name": "James Bond",
          "firstName": "James",
          "lastName": "Bond",
          "alternateEmailAddress": "james@gmail.com",
          "password": "qwe123",
          "requireAutoLoginToken": True,
          "isAdmin": True,
          "sendWelcomeEmail": True,
          "locale": "en-gb",
          "source": "standalone"
        }
    )

httpx.post(
    "https://bll.titan.email/partner/createEmailAccount",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "orderId": "partner.order.id",
      "email": "james@xyz.com",
      "name": "James Bond",
      "firstName": "James",
      "lastName": "Bond",
      "alternateEmailAddress": "james@gmail.com",
      "password": "qwe123",
      "requireAutoLoginToken": True,
      "isAdmin": True,
      "sendWelcomeEmail": True,
      "locale": "en-gb",
      "source": "standalone"
    }
)

async with httpx.AsyncClient() as client:
    await client.post(
        "https://bll.titan.email/partner/createEmailAccount",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "orderId": "partner.order.id",
          "email": "james@xyz.com",
          "name": "James Bond",
          "firstName": "James",
          "lastName": "Bond",
          "alternateEmailAddress": "james@gmail.com",
          "password": "qwe123",
          "requireAutoLoginToken": True,
          "isAdmin": True,
          "sendWelcomeEmail": True,
          "locale": "en-gb",
          "source": "standalone"
        }
    )

library(httr2)

response <- request("https://bll.titan.email/partner/createEmailAccount") |>
  req_method("POST") |>
  req_headers(
    "Authorization" = "API.Key",
    "Content-Type" = "application/json"
  ) |>
  req_body_json(list(
    titanOrderId = 1,
    orderId = "partner.order.id",
    email = "james@xyz.com",
    name = "James Bond",
    firstName = "James",
    lastName = "Bond",
    alternateEmailAddress = "james@gmail.com",
    password = "qwe123",
    requireAutoLoginToken = TRUE,
    isAdmin = TRUE,
    sendWelcomeEmail = TRUE,
    locale = "en-gb",
    source = "standalone"
  )) |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

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

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,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}
JSON

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

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

let request = client
    .post("https://bll.titan.email/partner/createEmailAccount")
    .header("Authorization", "API.Key")
    .header("Content-Type", "application/json")
    .json(&serde_json::json!({
        "titanOrderId": 1,
        "orderId": "partner.order.id",
        "email": "james@xyz.com",
        "name": "James Bond",
        "firstName": "James",
        "lastName": "Bond",
        "alternateEmailAddress": "james@gmail.com",
        "password": "qwe123",
        "requireAutoLoginToken": true,
        "isAdmin": true,
        "sendWelcomeEmail": true,
        "locale": "en-gb",
        "source": "standalone"
    }));

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

curl https://bll.titan.email/partner/createEmailAccount \
  --request POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --data '{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}'

wget --quiet \
  --method POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --body-data '{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}' \
  --output-document \
  - https://bll.titan.email/partner/createEmailAccount

http --ignore-stdin 'POST' 'https://bll.titan.email/partner/createEmailAccount' \
  'Authorization:API.Key' \
  'Content-Type:application/json' \
  --raw='{"titanOrderId":1,"orderId":"partner.order.id","email":"james@xyz.com","name":"James Bond","firstName":"James","lastName":"Bond","alternateEmailAddress":"james@gmail.com","password":"qwe123","requireAutoLoginToken":true,"isAdmin":true,"sendWelcomeEmail":true,"locale":"en-gb","source":"standalone"}'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/createEmailAccount")!)
request.httpMethod = "POST"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let jsonBody = #"""
{
  "titanOrderId": 1,
  "orderId": "partner.order.id",
  "email": "james@xyz.com",
  "name": "James Bond",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "james@gmail.com",
  "password": "qwe123",
  "requireAutoLoginToken": true,
  "isAdmin": true,
  "sendWelcomeEmail": true,
  "locale": "en-gb",
  "source": "standalone"
}
"""#
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",
  "titanAccountId": 1,
  "webmailAutoLoginToken": "adfadfweqwe"
}