API reference›Email Account Management APIs

Modify Email Account API

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

API to modify email account attributes on Titan Mail Cloud infra

Body

application/json

titanOrderIdnumberrequired

The unique order ID against each domain provisioned with Titan

Example: 1

titanAccountIdnumberoptional

unique account id at Titan's end.

Example: 123

emailstringrequired

Email account which needs to be modified

Example: info@xyz.com

namestringoptional

The name of the customer only if there is a change in the name.

Example: Rose

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

New alternate email address on which the customer can be contacted

Example: rose@gmail.com

passwordstringoptional

New password that needs to be setup against the account

Example: qwe123

isAdminbooleanoptional

Specifies whether or not the user is an admin

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. Must be set to a date from today up to a maximum of 30 days in the future. titanAccountId mandatorily to be passed while updating purgeAt. purgeAt date can only be increased for the account.

Example: 2020-02-20

Responses

200OKapplication/json

reqIDstringrequired

Example: server.req.id

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

POST/partner/modifyEmailAccount

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

  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"
    "  \"titanAccountId\": 123,\n"
    "  \"email\": \"info@xyz.com\",\n"
    "  \"name\": \"Rose\",\n"
    "  \"firstName\": \"James\",\n"
    "  \"lastName\": \"Bond\",\n"
    "  \"alternateEmailAddress\": \"rose@gmail.com\",\n"
    "  \"password\": \"qwe123\",\n"
    "  \"isAdmin\": true,\n"
    "  \"purgeAt\": \"2020-02-20\"\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/modifyEmailAccount");
request.Headers.TryAddWithoutValidation("Authorization", "API.Key");
request.Content = new StringContent(
"""
{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}
""",
System.Text.Encoding.UTF8, "application/json");

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

var client = new RestClient("https://bll.titan.email/partner/modifyEmailAccount");
var request = new RestRequest("", Method.Post);
request.AddHeader("Authorization", "API.Key");
request.AddHeader("Content-Type", "application/json");
request.AddStringBody("""
{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}
""", ContentType.Json);
var response = await client.ExecuteAsync(request);

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

(client/post "https://bll.titan.email/partner/modifyEmailAccount" {:headers {:Authorization "API.Key"}
                                                                   :content-type :json
                                                                   :form-params {:titanOrderId 1
                                                                                 :titanAccountId 123
                                                                                 :email "info@xyz.com"
                                                                                 :name "Rose"
                                                                                 :firstName "James"
                                                                                 :lastName "Bond"
                                                                                 :alternateEmailAddress "rose@gmail.com"
                                                                                 :password "qwe123"
                                                                                 :isAdmin true
                                                                                 :purgeAt "2020-02-20"}})

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,"titanAccountId":123,"email":"info@xyz.com","name":"Rose","firstName":"James","lastName":"Bond","alternateEmailAddress":"rose@gmail.com","password":"qwe123","isAdmin":true,"purgeAt":"2020-02-20"}';

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

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

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

let content = new StringContent("""{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}""", 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/modifyEmailAccount"

	payload := strings.NewReader(`{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}`)

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

{"titanOrderId":1,"titanAccountId":123,"email":"info@xyz.com","name":"Rose","firstName":"James","lastName":"Bond","alternateEmailAddress":"rose@gmail.com","password":"qwe123","isAdmin":true,"purgeAt":"2020-02-20"}

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

{"titanOrderId":1,"titanAccountId":123,"email":"info@xyz.com","name":"Rose","firstName":"James","lastName":"Bond","alternateEmailAddress":"rose@gmail.com","password":"qwe123","isAdmin":true,"purgeAt":"2020-02-20"}

java.io.ByteArrayOutputStream body = new java.io.ByteArrayOutputStream();
body.write("{\"titanOrderId\":1,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

try (AsyncHttpClient client = new DefaultAsyncHttpClient()) {
  Response response = client.prepare("POST", "https://bll.titan.email/partner/modifyEmailAccount")
    .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,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}".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/modifyEmailAccount"))
  .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,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}");

Request request = new Request.Builder()
  .url("https://bll.titan.email/partner/modifyEmailAccount")
  .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,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}".getBytes(java.nio.charset.StandardCharsets.UTF_8));

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

fetch('https://bll.titan.email/partner/modifyEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/modifyEmailAccount',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  }
}

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/modifyEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  }
})

$.ajax({
  url: "https://bll.titan.email/partner/modifyEmailAccount",
  method: "POST",
  processData: false,
  contentType: false,
  beforeSend(xhr) {
    xhr.setRequestHeader("Authorization", "API.Key");
    xhr.setRequestHeader("Content-Type", "application/json");
  },
  data: "{\"titanOrderId\":1,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}"
}).done((response) => console.log(response));

const xhr = new XMLHttpRequest();
xhr.open("POST", "https://bll.titan.email/partner/modifyEmailAccount");
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,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}");

using HTTP
using JSON

response = HTTP.post(
    "https://bll.titan.email/partner/modifyEmailAccount",
    [
        "Authorization" => "API.Key",
        "Content-Type" => "application/json"
    ],
    JSON.json(Dict(
        "titanOrderId" => 1,
        "titanAccountId" => 123,
        "email" => "info@xyz.com",
        "name" => "Rose",
        "firstName" => "James",
        "lastName" => "Bond",
        "alternateEmailAddress" => "rose@gmail.com",
        "password" => "qwe123",
        "isAdmin" => true,
        "purgeAt" => "2020-02-20"
    ))
)

println(String(response.body))

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\"titanOrderId\":1,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}")
val request = Request.Builder()
  .url("https://bll.titan.email/partner/modifyEmailAccount")
  .post(body)
  .addHeader("Authorization", "API.Key")
  .addHeader("Content-Type", "application/json")
  .build()

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

fetch('https://bll.titan.email/partner/modifyEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  })
})

import axios from 'axios'

const options = {
  method: 'POST',
  url: 'https://bll.titan.email/partner/modifyEmailAccount',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  data: {
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  }
}

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/modifyEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: {
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  }
})

import { request } from 'undici'

const { statusCode, body } = await request('https://bll.titan.email/partner/modifyEmailAccount', {
  method: 'POST',
  headers: {
    Authorization: 'API.Key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    titanOrderId: 1,
    titanAccountId: 123,
    email: 'info@xyz.com',
    name: 'Rose',
    firstName: 'James',
    lastName: 'Bond',
    alternateEmailAddress: 'rose@gmail.com',
    password: 'qwe123',
    isAdmin: true,
    purgeAt: '2020-02-20'
  })
})

#import <Foundation/Foundation.h>

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

NSDictionary *parameters = @{ @"titanOrderId": @1,
                              @"titanAccountId": @123,
                              @"email": @"info@xyz.com",
                              @"name": @"Rose",
                              @"firstName": @"James",
                              @"lastName": @"Bond",
                              @"alternateEmailAddress": @"rose@gmail.com",
                              @"password": @"qwe123",
                              @"isAdmin": @YES,
                              @"purgeAt": @"2020-02-20" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bll.titan.email/partner/modifyEmailAccount"]
                                                      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/modifyEmailAccount" in
    let headers = Cohttp.Header.of_list [
      ("Authorization", "API.Key");
      ("Content-Type", "application/json");
    ] in
    let part0 = "{\"titanOrderId\":1,\"titanAccountId\":123,\"email\":\"info@xyz.com\",\"name\":\"Rose\",\"firstName\":\"James\",\"lastName\":\"Bond\",\"alternateEmailAddress\":\"rose@gmail.com\",\"password\":\"qwe123\",\"isAdmin\":true,\"purgeAt\":\"2020-02-20\"}" 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/modifyEmailAccount");

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,
  'titanAccountId' => 123,
  'email' => 'info@xyz.com',
  'name' => 'Rose',
  'firstName' => 'James',
  'lastName' => 'Bond',
  'alternateEmailAddress' => 'rose@gmail.com',
  'password' => 'qwe123',
  'isAdmin' => true,
  'purgeAt' => '2020-02-20'
]));

curl_exec($ch);

curl_close($ch);

$client = new GuzzleHttp\Client();

$response = $client->request('POST', 'https://bll.titan.email/partner/modifyEmailAccount', [
  'headers' => [
    'Authorization' => 'API.Key',
    'Content-Type' => 'application/json'
  ],
  'json' => [
    'titanOrderId' => 1,
    'titanAccountId' => 123,
    'email' => 'info@xyz.com',
    'name' => 'Rose',
    'firstName' => 'James',
    'lastName' => 'Bond',
    'alternateEmailAddress' => 'rose@gmail.com',
    'password' => 'qwe123',
    'isAdmin' => true,
    'purgeAt' => '2020-02-20'
  ]
]);

use Illuminate\Support\Facades\Http;

$response = Http::withHeaders([
  'Authorization' => 'API.Key',
  'Content-Type' => 'application/json'
])
  ->post('https://bll.titan.email/partner/modifyEmailAccount', [
    'titanOrderId' => 1,
    'titanAccountId' => 123,
    'email' => 'info@xyz.com',
    'name' => 'Rose',
    'firstName' => 'James',
    'lastName' => 'Bond',
    'alternateEmailAddress' => 'rose@gmail.com',
    'password' => 'qwe123',
    'isAdmin' => true,
    'purgeAt' => '2020-02-20'
  ]);

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

$body = [System.IO.MemoryStream]::new()
$bytes = [System.Text.Encoding]::UTF8.GetBytes('{"titanOrderId":1,"titanAccountId":123,"email":"info@xyz.com","name":"Rose","firstName":"James","lastName":"Bond","alternateEmailAddress":"rose@gmail.com","password":"qwe123","isAdmin":true,"purgeAt":"2020-02-20"}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-WebRequest -Uri 'https://bll.titan.email/partner/modifyEmailAccount' -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,"titanAccountId":123,"email":"info@xyz.com","name":"Rose","firstName":"James","lastName":"Bond","alternateEmailAddress":"rose@gmail.com","password":"qwe123","isAdmin":true,"purgeAt":"2020-02-20"}')
$body.Write($bytes, 0, $bytes.Length)

$response = Invoke-RestMethod -Uri 'https://bll.titan.email/partner/modifyEmailAccount' -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,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": True,
  "purgeAt": "2020-02-20"
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

conn.request(
    "POST",
    "/partner/modifyEmailAccount",
    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,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": True,
  "purgeAt": "2020-02-20"
})
headers = {
  "Authorization": "API.Key",
  "Content-Type": "application/json"
}

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

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

conn.close()

requests.post(
    "https://bll.titan.email/partner/modifyEmailAccount",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "titanAccountId": 123,
      "email": "info@xyz.com",
      "name": "Rose",
      "firstName": "James",
      "lastName": "Bond",
      "alternateEmailAddress": "rose@gmail.com",
      "password": "qwe123",
      "isAdmin": True,
      "purgeAt": "2020-02-20"
    }
)

async with aiohttp.ClientSession() as session:
    await session.post(
        "https://bll.titan.email/partner/modifyEmailAccount",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "titanAccountId": 123,
          "email": "info@xyz.com",
          "name": "Rose",
          "firstName": "James",
          "lastName": "Bond",
          "alternateEmailAddress": "rose@gmail.com",
          "password": "qwe123",
          "isAdmin": True,
          "purgeAt": "2020-02-20"
        }
    )

httpx.post(
    "https://bll.titan.email/partner/modifyEmailAccount",
    headers={
      "Authorization": "API.Key",
      "Content-Type": "application/json"
    },
    json={
      "titanOrderId": 1,
      "titanAccountId": 123,
      "email": "info@xyz.com",
      "name": "Rose",
      "firstName": "James",
      "lastName": "Bond",
      "alternateEmailAddress": "rose@gmail.com",
      "password": "qwe123",
      "isAdmin": True,
      "purgeAt": "2020-02-20"
    }
)

async with httpx.AsyncClient() as client:
    await client.post(
        "https://bll.titan.email/partner/modifyEmailAccount",
        headers={
          "Authorization": "API.Key",
          "Content-Type": "application/json"
        },
        json={
          "titanOrderId": 1,
          "titanAccountId": 123,
          "email": "info@xyz.com",
          "name": "Rose",
          "firstName": "James",
          "lastName": "Bond",
          "alternateEmailAddress": "rose@gmail.com",
          "password": "qwe123",
          "isAdmin": True,
          "purgeAt": "2020-02-20"
        }
    )

library(httr2)

response <- request("https://bll.titan.email/partner/modifyEmailAccount") |>
  req_method("POST") |>
  req_headers(
    "Authorization" = "API.Key",
    "Content-Type" = "application/json"
  ) |>
  req_body_json(list(
    titanOrderId = 1,
    titanAccountId = 123,
    email = "info@xyz.com",
    name = "Rose",
    firstName = "James",
    lastName = "Bond",
    alternateEmailAddress = "rose@gmail.com",
    password = "qwe123",
    isAdmin = TRUE,
    purgeAt = "2020-02-20"
  )) |>
  req_perform()

resp_body_string(response)

require 'uri'
require 'net/http'

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

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,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}
JSON

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

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

let request = client
    .post("https://bll.titan.email/partner/modifyEmailAccount")
    .header("Authorization", "API.Key")
    .header("Content-Type", "application/json")
    .json(&serde_json::json!({
        "titanOrderId": 1,
        "titanAccountId": 123,
        "email": "info@xyz.com",
        "name": "Rose",
        "firstName": "James",
        "lastName": "Bond",
        "alternateEmailAddress": "rose@gmail.com",
        "password": "qwe123",
        "isAdmin": true,
        "purgeAt": "2020-02-20"
    }));

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

curl https://bll.titan.email/partner/modifyEmailAccount \
  --request POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --data '{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}'

wget --quiet \
  --method POST \
  --header 'Authorization: API.Key' \
  --header 'Content-Type: application/json' \
  --body-data '{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}' \
  --output-document \
  - https://bll.titan.email/partner/modifyEmailAccount

http --ignore-stdin 'POST' 'https://bll.titan.email/partner/modifyEmailAccount' \
  'Authorization:API.Key' \
  'Content-Type:application/json' \
  --raw='{"titanOrderId":1,"titanAccountId":123,"email":"info@xyz.com","name":"Rose","firstName":"James","lastName":"Bond","alternateEmailAddress":"rose@gmail.com","password":"qwe123","isAdmin":true,"purgeAt":"2020-02-20"}'

import Foundation

var request = URLRequest(url: URL(string: "https://bll.titan.email/partner/modifyEmailAccount")!)
request.httpMethod = "POST"
request.setValue("API.Key", forHTTPHeaderField: "Authorization")
request.setValue("application/json", forHTTPHeaderField: "Content-Type")
let jsonBody = #"""
{
  "titanOrderId": 1,
  "titanAccountId": 123,
  "email": "info@xyz.com",
  "name": "Rose",
  "firstName": "James",
  "lastName": "Bond",
  "alternateEmailAddress": "rose@gmail.com",
  "password": "qwe123",
  "isAdmin": true,
  "purgeAt": "2020-02-20"
}
"""#
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"
}