API reference›Mail Order Management APIs

Transfer Mail Order

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

Transfer Mail Order from one customer account to another
If a titan user profile for the new customerId does not already exist a new profile will be created using information passed or else order will be moved to the existing titan user profile.
Customer profile should be in the active state.
The order's status can be anything (active, suspended, ...)
serverHostName will be only applicable for partners using Titan's cPanel/plesk plugins.

Body

application/json

titanOrderIdnumberrequired

The unique order ID against each domain provisioned with Titan

Example: 1

transferToobjectoptional

Show propertiesHide properties

customerIdstringrequired

Unique ID on your side for this customer

Example: titanuser

customerNamestringoptional

Customer name

Example: Titan User

customerEmailAddressstringrequired

Customer email address All communications will be sent here This will also be the primary admin for the domain

Example: titanuser@titan.mail

customerCountrystringoptional

Customer country, 2 letter ISO Code

Example: US

serverHostNamestringoptional

hostname of the hosting-server where user's hosting order has been provisioned It's expected that only 1 server is registered with the given hostname. API fails if there are multiple

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

400BAD_REQUEST

domain customer is not in active state.

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

POST/partner/transferMailOrder

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

  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"
    "  \"transferTo\": {\n"
    "    \"customerId\": \"titanuser\",\n"
    "    \"customerName\": \"Titan User\",\n"
    "    \"customerEmailAddress\": \"titanuser@titan.mail\",\n"
    "    \"customerCountry\": \"US\",\n"
    "    \"serverHostName\": \"string\"\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/transferMailOrder");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");
request.Content = new StringContent(
"""
{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}
""",
System.Text.Encoding.UTF8, "application/json");

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

var client = new RestClient("https://bll.titan.email/partner/transferMailOrder");
var request = new RestRequest("", Method.Post);
request.AddHeader("Authorization", "API.Key");
request.AddHeader("Content-Type", "application/json");
request.AddStringBody("""
{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}
""", ContentType.Json);
var response = await client.ExecuteAsync(request);

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

(client/post "https://bll.titan.email/partner/transferMailOrder" {:headers {:Authorization "API.Key"}
                                                                  :content-type :json
                                                                  :form-params {:titanOrderId 1
                                                                                :transferTo {:customerId "titanuser"
                                                                                             :customerName "Titan User"
                                                                                             :customerEmailAddress "titanuser@titan.mail"
                                                                                             :customerCountry "US"
                                                                                             :serverHostName "string"}}})

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,"transferTo":{"customerId":"titanuser","customerName":"Titan User","customerEmailAddress":"titanuser@titan.mail","customerCountry":"US","serverHostName":"string"}}';

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

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

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

let content = new StringContent("""{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}""", 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/transferMailOrder"

	payload := strings.NewReader(`{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}`)

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

{"titanOrderId":1,"transferTo":{"customerId":"titanuser","customerName":"Titan User","customerEmailAddress":"titanuser@titan.mail","customerCountry":"US","serverHostName":"string"}}

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

{"titanOrderId":1,"transferTo":{"customerId":"titanuser","customerName":"Titan User","customerEmailAddress":"titanuser@titan.mail","customerCountry":"US","serverHostName":"string"}}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("POST", "https://bll.titan.email/partner/transferMailOrder")
    .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,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}".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/transferMailOrder"))
  .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,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}");

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/transferMailOrder")
  .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,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

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

fetch('https://bll.titan.email/partner/transferMailOrder', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/transferMailOrder',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  }
}

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/transferMailOrder', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/transferMailOrder",
  method: "POST",
  processData: false,
  contentType: false,
  beforeSend(xhr) {
    xhr.setRequestHeader("Authorization", "API.Key");
    xhr.setRequestHeader("Content-Type", "application/json");
  },
  data: "{\"titanOrderId\":1,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}"
}).done((response) => console.log(response));

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://bll.titan.email/partner/transferMailOrder");
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,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}");

using HTTP
using JSON

response = HTTP.post(
    "https://bll.titan.email/partner/transferMailOrder",
    [
        "Authorization" => "API.Key",
        "Content-Type" => "application/json"
    ],
    JSON.json(Dict(
        "titanOrderId" => 1,
        "transferTo" => Dict(
            "customerId" => "titanuser",
            "customerName" => "Titan User",
            "customerEmailAddress" => "titanuser@titan.mail",
            "customerCountry" => "US",
            "serverHostName" => "string"
        )
    ))
)

println(String(response.body))

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"titanOrderId\":1,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}")
val request = Request.Builder()
  .url("https://bll.titan.email/partner/transferMailOrder")
  .post(body)
  .addHeader("Authorization", "API.Key")
  .addHeader("Content-Type", "application/json")
  .build()

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

fetch('https://bll.titan.email/partner/transferMailOrder', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/transferMailOrder',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  }
}

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/transferMailOrder', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/transferMailOrder', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    transferTo: {
      customerId: 'titanuser',
      customerName: 'Titan User',
      customerEmailAddress: 'titanuser@titan.mail',
      customerCountry: 'US',
      serverHostName: 'string'
    }
  })
})

#import <Foundation/Foundation.h>

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

NSDictionary *parameters = @{ @"titanOrderId": @1,
                              @"transferTo": @{ @"customerId": @"titanuser", @"customerName": @"Titan User", @"customerEmailAddress": @"titanuser@titan.mail", @"customerCountry": @"US", @"serverHostName": @"string" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/transferMailOrder"]
                                                      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/transferMailOrder" in
    let headers = Cohttp.Header.of_list [
      ("Authorization", "API.Key");
      ("Content-Type", "application/json");
    ] in
    let part0 = "{\"titanOrderId\":1,\"transferTo\":{\"customerId\":\"titanuser\",\"customerName\":\"Titan User\",\"customerEmailAddress\":\"titanuser@titan.mail\",\"customerCountry\":\"US\",\"serverHostName\":\"string\"}}" 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/transferMailOrder");

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,
  'transferTo' => [
    'customerId' => 'titanuser',
    'customerName' => 'Titan User',
    'customerEmailAddress' => 'titanuser@titan.mail',
    'customerCountry' => 'US',
    'serverHostName' => 'string'
  ]
]));

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

$response = $client->request('POST', 'https://bll.titan.email/partner/transferMailOrder', [
  'headers' => [
    'Authorization' => 'API.Key',
    'Content-Type' => 'application/json'
  ],
  'json' => [
    'titanOrderId' => 1,
    'transferTo' => [
      'customerId' => 'titanuser',
      'customerName' => 'Titan User',
      'customerEmailAddress' => 'titanuser@titan.mail',
      'customerCountry' => 'US',
      'serverHostName' => 'string'
    ]
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key',
  'Content-Type' => 'application/json'
])
  ->post('https://bll.titan.email/partner/transferMailOrder', [
    'titanOrderId' => 1,
    'transferTo' => [
      'customerId' => 'titanuser',
      'customerName' => 'Titan User',
      'customerEmailAddress' => 'titanuser@titan.mail',
      'customerCountry' => 'US',
      'serverHostName' => 'string'
    ]
  ]);

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

$body = [System.IO.MemoryStream]::new()
$bytes = [System.Text.Encoding]::UTF8.GetBytes('{"titanOrderId":1,"transferTo":{"customerId":"titanuser","customerName":"Titan User","customerEmailAddress":"titanuser@titan.mail","customerCountry":"US","serverHostName":"string"}}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/transferMailOrder' -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,"transferTo":{"customerId":"titanuser","customerName":"Titan User","customerEmailAddress":"titanuser@titan.mail","customerCountry":"US","serverHostName":"string"}}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/transferMailOrder' -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,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/partner/transferMailOrder",
    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,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

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

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

conn.close()

requests.post(
    "https://bll.titan.email/partner/transferMailOrder",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "transferTo": {
        "customerId": "titanuser",
        "customerName": "Titan User",
        "customerEmailAddress": "titanuser@titan.mail",
        "customerCountry": "US",
        "serverHostName": "string"
      }
    }
)

async with aiohttp.ClientSession() as session:
    await session.post(
        "https://bll.titan.email/partner/transferMailOrder",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "transferTo": {
            "customerId": "titanuser",
            "customerName": "Titan User",
            "customerEmailAddress": "titanuser@titan.mail",
            "customerCountry": "US",
            "serverHostName": "string"
          }
        }
    )

httpx.post(
    "https://bll.titan.email/partner/transferMailOrder",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "transferTo": {
        "customerId": "titanuser",
        "customerName": "Titan User",
        "customerEmailAddress": "titanuser@titan.mail",
        "customerCountry": "US",
        "serverHostName": "string"
      }
    }
)

async with httpx.AsyncClient() as client:
    await client.post(
        "https://bll.titan.email/partner/transferMailOrder",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "transferTo": {
            "customerId": "titanuser",
            "customerName": "Titan User",
            "customerEmailAddress": "titanuser@titan.mail",
            "customerCountry": "US",
            "serverHostName": "string"
          }
        }
    )

library(httr2)

response <- request("https://bll.titan.email/partner/transferMailOrder") |>
  req_method("POST") |>
  req_headers(
    "Authorization" = "API.Key",
    "Content-Type" = "application/json"
  ) |>
  req_body_json(list(
    titanOrderId = 1,
    transferTo = list(
      customerId = "titanuser",
      customerName = "Titan User",
      customerEmailAddress = "titanuser@titan.mail",
      customerCountry = "US",
      serverHostName = "string"
    )
  )) |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

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

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,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}
JSON

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

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

let request = client
    .post("https://bll.titan.email/partner/transferMailOrder")
    .header("Authorization", "API.Key")
    .header("Content-Type", "application/json")
    .json(&serde_json::json!({
        "titanOrderId": 1,
        "transferTo": {
            "customerId": "titanuser",
            "customerName": "Titan User",
            "customerEmailAddress": "titanuser@titan.mail",
            "customerCountry": "US",
            "serverHostName": "string"
        }
    }));

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

curl https://bll.titan.email/partner/transferMailOrder \
  --request POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --data '{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}'

wget --quiet \
  --method POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --body-data '{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}' \
  --output-document \
  - https://bll.titan.email/partner/transferMailOrder

http --ignore-stdin 'POST' 'https://bll.titan.email/partner/transferMailOrder' \
  'Authorization:API.Key' \
  'Content-Type:application/json' \
  --raw='{"titanOrderId":1,"transferTo":{"customerId":"titanuser","customerName":"Titan User","customerEmailAddress":"titanuser@titan.mail","customerCountry":"US","serverHostName":"string"}}'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/transferMailOrder")!)
request.httpMethod = "POST"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let jsonBody = #"""
{
  "titanOrderId": 1,
  "transferTo": {
    "customerId": "titanuser",
    "customerName": "Titan User",
    "customerEmailAddress": "titanuser@titan.mail",
    "customerCountry": "US",
    "serverHostName": "string"
  }
}
"""#
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"
}