curl --include \
     --request POST \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"username\":\"johndoe1\",
        \"user_email\":\"johndoe1@awesome.com\",
        \"user_phone\":\"518-481-1001\",
        \"user_first_name\":\"John\",
        \"user_last_name\":\"Doe\",
        \"country\":\"US\",
        \"password\":\"pass\",
        \"account_name\":\"The Awesome Company\"
    }" \
'https://rest.clicksend.com/v3/account'

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
$account = new \ClickSend\Model\Account(); // \ClickSend\Model\Account | Account model
$account->setUserName("johndoe");
$account->setPassword("pass");
$account->setUserPhone("533-481-1041");
$account->setUserEmail("johndoesdfds1@awesome.com");
$account->setUserFirstName("John");
$account->setUserLastName("Doe");
$account->setAccountName("The Awesome Company");
$account->setCountry("US");

try {
    $result = $apiInstance->accountPost($account);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->accountPost: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

var accountApi = new AccountApi(Configuration.Default);
var account = new Account(
    username: "username",
    password: "password",
    userPhone: "+1231231234",
    userEmail: "johndoe@company.com",
    userFirstName: "John",
    userLastName: "Doe",
    accountName: "Your_Account_Name",
    country: "CA"
);
var response = accountApi.AccountPost(account);

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var account = new api.Account();

account.username = "username";
account.password = "pass";
account.userPhone = "xxx-xxx-xxxx";
account.userEmail = "xxx@gmail.com";
account.userFirstName = "test";
account.userLastName = "test";
account.accountName = "testing";
account.country = "country";

accountApi.accountPost(account).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

# Account | Account model
account = ClickSendClient::Account.new(
  "country": "country",
  "password": "password",
  "user_email": "user_email",
  "user_first_name": "user_first_name",
  "user_last_name": "user_last_name",
  "account_name": "account_name",
  "user_phone": "user_phone",
  "username": "username"
)

begin
  # Create a new account
  result = api_instance.account_post(account)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->account_post: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
account = clicksend_client.Account(
          username="username",
          user_email="xxx@gmail.com",
          user_phone="xxx-xxx-xxxx",
          user_first_name="John",
          user_last_name="Doe",
          country="US",
          password="pass",
          account_name="The Awesome Company") # Account | Account model

try:
    # Create a new account
    api_response = api_instance.account_post(account)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->account_post: %s\n" % e)

use WWW::ClickSendClient::AccountApi;
use WWW::ClickSendClient::Object::Account;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountApi->new(username => $username, password => $password);

my %params = (
    'username'        => 'test_username',
    'password'        => 'Test-password@123',
    'user_phone'      => '111-111-11111',
    'user_email'      => 'test1@test.com',
    'user_first_name' => 'user_first_name',
    'user_last_name'  => 'user_last_name',
    'account_name'    => 'account_name',
    'country'         => 'US'
);

my $acc_obj = WWW::ClickSendClient::Object::Account->new(%params);
my $json_output = $api->account_post('account' => $acc_obj);

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];

CSAccount *account =  [[CSAccount alloc] init];
account.username = @"johndoe1";
account.password = @"password";
account.userPhone = @"518-481-1001";
account.userEmail = @"johndoe1@awesome.com";
account.userFirstName = @"John";
account.userLastName = @"Doe";
account.accountName = @"Awesome company name";
account.country = @"country";

[accountAPI accountPostWithAccount:account completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"Output: %@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let account = Account(
    username: "johndoe1", 
    password: "password", 
    userPhone: "518-481-1001", 
    userEmail: "johndoe1@awesome.com", 
    userFirstName: "John", 
    userLastName: "Doe", 
    accountName: "The Awesome Company", 
    country: "userCountry"
)

AccountAPI.accountPost(account: account) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.Account;

public class create_account {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    Account account = new Account(); // Account | Account model
    account.accountName("account Name");
    account.username("username");
    account.password("pwd");
    account.country("country");
    account.userEmail("xxx@gmail.com");
    account.userPhone("000-000-0000");
    account.userFirstName("firstname");
    account.userLastName("lastname");
    try {
        String result = apiInstance.accountPost(account);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#accountPost");
        e.printStackTrace();
    }
  }
}

{
  "country": "country",
  "password": "password",
  "user_email": "user_email",
  "user_first_name": "user_first_name",
  "user_last_name": "user_last_name",
  "account_name": "account_name",
  "user_phone": "user_phone",
  "username": "username"
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Successfully created an account.",
  "data": {
    "user_id": 116,
    "username": "johndoe1",
    "user_email": "johndoe1@awesome.com",
    "active": 0,
    "banned": 0,
    "balance": "4.998000",
    "user_phone": "+15184811001",
    "reply_to": "originalemail",
    "delivery_to": null,
    "user_first_name": "John",
    "user_last_name": "Doe",
    "account": 0,
    "account_name": "The Awesome Company",
    "account_billing_email": "johndoe1@awesome.com",
    "account_billing_mobile": "+15184811001",
    "country": "US",
    "default_country_sms": "US",
    "auto_recharge": 0,
    "auto_recharge_amount": "20.00",
    "low_credit_amount": "0.00",
    "setting_unicode_sms": 0,
    "setting_email_sms_subject": 0,
    "setting_fix_sender_id": 0,
    "setting_sms_message_char_limit": 6,
    "old_dashboard": 0,
    "balance_commission": "0.299954",
    "timezone": "Australia/Melbourne",
    "_currency": {
      "currency_name_short": "USD",
      "currency_prefix_d": "$",
      "currency_prefix_c": "¢",
      "currency_name_long": "US Dollars"
    },
    "_subaccount": {
      "subaccount_id": 126,
      "api_username": "johndoe1",
      "email": "johndoe1@awesome.com",
      "phone_number": "+15184811001",
      "first_name": "John",
      "last_name": "Doe",
      "api_key": "F3702045-EB2C-0091-C211-7728048DCAE2",
      "access_users": 1,
      "access_billing": 1,
      "access_reporting": 1,
      "access_contacts": 1,
      "access_settings": 1,
      "access_sms": 1,
      "access_email": 1,
      "access_voice": 1,
      "access_fax": 1,
      "access_post": 1,
      "access_reseller": 1,
      "access_mms": 1,
      "share_campaigns": 0,
      "notes": null
    }
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \

'https://rest.clicksend.com/v3/account'

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);

try {
    $result = $apiInstance->accountGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->accountGet: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var configuration = new Configuration()
{
    Username = USERNAME, 
    Password = API_KEY  
};
var accountApi = new AccountApi(configuration);
var response = accountApi.AccountGet();

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

accountApi.accountGet().then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

begin
  # Get account information
  result = api_instance.account_get
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->account_get: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))

try:
    # Get account information
    api_response = api_instance.account_get()
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->account_get: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountApi->new(username => $username, password => $password);

my $json_output = $api->account_get();

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];
[accountAPI accountGetWithCompletionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"Output: %@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

AccountAPI.accountGet { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;

public class view_account_detail {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    try {
        String result = apiInstance.accountGet();
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#accountGet");
        e.printStackTrace();
    }
  }
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Here's your account",
  "data": {
    "user_id": 3819,
    "username": "ULXHP",
    "user_email": "PNUMB@VAPXX.com",
    "active": 1,
    "banned": 0,
    "balance": "1117.461060",
    "user_phone": "+61433333888",
    "user_first_name": "fffff",
    "user_last_name": "llll",
    "account": 0,
    "account_name": "FTHCQ~!@#$ %^&*()XQMPO",
    "account_billing_email": "XDVXC@SJRJU.com",
    "account_billing_mobile": "+61433333888",
    "country": "AU",
    "default_country_sms": "AU",
    "auto_recharge": 0,
    "auto_recharge_amount": "20.00",
    "low_credit_amount": "0.00",
    "setting_unicode_sms": 0,
    "setting_email_sms_subject": 0,
    "setting_fix_sender_id": 0,
    "setting_sms_message_char_limit": 8,
    "old_dashboard": 0,
    "balance_commission": "2.330130",
    "timezone": "Australia/Melbourne",
    "private_uploads": 0,
    "fax_quality": 0,
    "setting_sms_hide_your_number": 0,
    "setting_sms_hide_business_name": 1,
    "_currency": {
      "currency_name_short": "AUD",
      "currency_prefix_d": "$",
      "currency_prefix_c": "c",
      "currency_name_long": "Australian Dollars"
    },
    "_subaccount": {
      "subaccount_id": 1716,
      "api_username": "KCIHOYEYGM",
      "email": "ICMGR@VBSPT.com",
      "phone_number": "+61433333333",
      "first_name": "Firstname40710",
      "last_name": "Lastname3672",
      "api_key": "IJVEGTCF-VOHU-GSVF-KNKK-XHTARJXMQTXK",
      "access_users": 1,
      "access_billing": 1,
      "access_reporting": 1,
      "access_contacts": 0,
      "access_settings": 1,
      "access_sms": 0,
      "access_email": 0,
      "access_voice": 0,
      "access_fax": 0,
      "access_post": 0,
      "access_reseller": 0,
      "access_mms": 1,
      "share_campaigns": 1,
      "notes": null
    }
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \

'https://rest.clicksend.com/v3/account/usage/{year}/{month}/subaccount'

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

    Coming Soon

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Here is your usage for this month.",
  "data": {
    "sms": [
      {
        "subaccount_id": 1039,
        "username": "gerald",
        "total_count": "29.00",
        "total_price": "2.1337"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "4.00",
        "total_price": "0.3080"
      }
    ],
    "voice": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": "6.00",
        "total_price": "0.1980"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "1.00",
        "total_price": "0.0330"
      }
    ],
    "fax": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": "3.00",
        "total_price": "0.6943"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "1.00",
        "total_price": "0.2314"
      }
    ],
    "post": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": "10",
        "total_price": "8.5624"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": "3",
        "total_price": "2.5586"
      }
    ],
    "email": [
      {
        "subaccount_id": 1039,
        "username": "user1",
        "total_count": 3992,
        "total_price": "9.0020"
      },
      {
        "subaccount_id": 1047,
        "username": "user5",
        "total_count": 998,
        "total_price": "0.0000"
      }
    ],
    "sms_total": {
      "count": 33,
      "price": "2.4417"
    },
    "voice_total": {
      "count": 7,
      "price": "0.2310"
    },
    "fax_total": {
      "count": 4,
      "price": "0.9257"
    },
    "post_total": {
      "count": 13,
      "price": "11.1210"
    },
    "email_total": {
      "count": 4990,
      "price": "9.0020"
    }
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
     --request PUT \
     --header "Content-Type: application/json" \

     --data-binary "    {
        \"user_phone\":\"352-394-4199\",
        \"type\":\"sms\",
        \"country\": \"US\"
    }" \
'https://rest.clicksend.com/v3/account-verify/send'

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
// \ClickSend\Model\AccountVerify | Account details
$account_verify = new \ClickSend\Model\AccountVerify(); 
$account_verify->setCountry("US");
$account_verify->setUserPhone("352-394-4199");
$account_verify->setType("sms");

try {
    $result = $apiInstance->accountVerifySendPut($account_verify);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->accountVerifySendPut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

var configuration = new Configuration()
{
    Username = USERNAME, 
    Password = API_KEY  
};
var accountApi = new AccountApi(configuration);
var response = accountApi.AccountVerifySendPut(new AccountVerify(
    country: "US",
    userPhone: "+11231231234",
    type: "sms"
));

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var accountVerify = new api.AccountVerify();

accountVerify.country = "US";
accountVerify.userPhone = "xxx-xxx-xxxx";
accountVerify.type = "SMS";

accountApi.accountVerifySendPut(accountVerify).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

# AccountVerify | Account details
account_verify = ClickSendClient::AccountVerify.new(
  "country": "country",
  "user_phone": "user_phone",
  "type": "sms"
)

begin
  # Send account activation token
  result = api_instance.account_verify_send_put(account_verify)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->account_verify_send_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
account_verify = clicksend_client.AccountVerify(
                  user_phone="xxx-xxx-xxxx",
                  type="sms",
                  country="US") # AccountVerify | Account details

try:
    # Send account activation token
    api_response = api_instance.account_verify_send_put(account_verify)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->account_verify_send_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;
use WWW::ClickSendClient::Object::AccountVerify;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountApi->new(username => $username, password => $password);

my %params = (
    'country'    => 'US',
    'user_phone' => '+111111111111',
    'type'       => 'sms'
);

my $acc_obj = WWW::ClickSendClient::Object::AccountVerify->new(%params);
my $json_output = $api->account_verify_send_put('account_verify' => $acc_obj);

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];

CSAccountVerify *accountVerify = [[CSAccountVerify alloc] init];
accountVerify.country = @"US";
accountVerify.userPhone = @"352-394-4199";
accountVerify.type = @"sms";

[accountAPI accountVerifySendPutWithAccountVerify:accountVerify completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"Output: %@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let accountVerify = AccountVerify(
    country: "US", 
    userPhone: "352-394-4199", 
    type: "sms"
)

AccountAPI.accountVerifySendPut(accountVerify: accountVerify) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.AccountVerify;

public class send_account_verification {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    AccountVerify accountVerify = new AccountVerify(); // AccountVerify | Account details
    accountVerify.country("IN");
    accountVerify.type("sms");
    accountVerify.userPhone("000-000-0000");
    try {
        String result = apiInstance.accountVerifySendPut(accountVerify);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#accountVerifySendPut");
        e.printStackTrace();
    }
  }
}

{
  "country": "country",
  "user_phone": "user_phone",
  "type": "sms"
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "Verification sent.",
  "data": {
    "user_phone": "+13523944199",
    "type": "sms",
    "country": "US"
  }
}

curl --include \
     --header "Authorization: Basic YXBpLXVzZXJuYW1lOmFwaS1wYXNzd29yZA=="  \
     --request PUT \

'https://rest.clicksend.com/v3/account-verify/verify/{activation_token}'

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
$activation_token = 56; // int | 

try {
    $result = $apiInstance->accountVerifyVerifyByActivationTokenPut($activation_token);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->accountVerifyVerifyByActivationTokenPut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;
using IO.ClickSend.ClickSend.Model;

var configuration = new Configuration()
{
    Username = USERNAME, 
    Password = API_KEY  
};
var accountApi = new AccountApi(configuration);
var response = accountApi.AccountVerifyVerifyByActivationTokenPut(ACTIVATION_CODE);

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var activationToken = "activation_token";

accountApi.accountVerifyVerifyByActivationTokenPut(activationToken).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

activation_token = 56 # Integer |

begin
  # Verify new account
  result = api_instance.account_verify_verify_by_activation_token_put(activation_token)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->account_verify_verify_by_activation_token_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
activation_token = 56 # int | 

try:
    # Verify new account
    api_response = api_instance.account_verify_verify_by_activation_token_put(activation_token)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->account_verify_verify_by_activation_token_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $username = 'YOUR_API_USER_NAME';
my $password = 'YOUR_API_PASSWORD';

my $api = WWW::ClickSendClient::AccountApi->new(username => $username, password => $password);
my $json_output = $api->account_verify_verify_by_activation_token_put('activation_token' => 'XXXXXX-XXXXXX-XXXX-XXXXXXX');

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];
NSNumber *token = [NSNumber numberWithInt:123456];
[accountAPI accountVerifyVerifyByActivationTokenPutWithActivationToken:token completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"Output: %@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let token = 123456
AccountAPI.accountVerifyVerifyByActivationTokenPut(activationToken: token) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;

public class verify_account {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    Integer activationToken = 56; // Integer | 
    try {
        String result = apiInstance.accountVerifyVerifyByActivationTokenPut(activationToken);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#accountVerifyVerifyByActivationTokenPut");
        e.printStackTrace();
    }
  }
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "You're account has been verified.",
  "data": {
    "user_id": 1,
    "username": "1",
    "user_email": "1@test.com",
    "active": 1,
    "banned": 0,
    "balance": "4.041500",
    "user_phone": "+13523944199",
    "reply_to": "1@test.com",
    "delivery_to": null,
    "user_first_name": "John",
    "user_last_name": "Doe",
    "account": 1,
    "account_name": null,
    "account_billing_email": "1@test.com",
    "account_billing_mobile": null,
    "country": "US",
    "default_country_sms": "US",
    "unsubscribe_mail": 0,
    "auto_recharge": 0,
    "auto_recharge_amount": "20.00",
    "low_credit_amount": "1.50",
    "setting_unicode_sms": 0,
    "setting_beta": 0,
    "setting_email_sms_subject": 0,
    "setting_fix_sender_id": 1,
    "_currency": {
      "currency_name_short": "USD",
      "currency_prefix_d": "$",
      "currency_prefix_c": "¢",
      "currency_name_long": "US Dollars"
    },
    "_subaccount": {
      "subaccount_id": 1,
      "api_username": "1",
      "email": "1@test.com",
      "mobile": "+639171234501",
      "first_name": "John",
      "last_name": "Doe",
      "api_key": "FD3259F9D0A35548682ACEA84A6FF26A",
      "user_id": 1,
      "sms_deidentify_message": 0,
      "access_smpp": 0,
      "access_users": 1,
      "access_billing": 1,
      "access_reporting": 1,
      "access_contacts": 0,
      "access_settings": 1
    }
  }
}

curl --include \
     --request PUT \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"phone_number\": \"3108147982\",
        \"email\": \"test@email.com\"
    }" \
'https://rest.clicksend.com/v3/forgot-username'

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client());
$forgot_username = new \ClickSend\Model\ForgotUsername(); // \ClickSend\Model\ForgotUsername | 
$forgot_username->setEmail("xxx@gmail.com");

try {
    $result = $apiInstance->forgotUsernamePut($forgot_username);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->forgotUsernamePut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var accountApi = new AccountApi(Configuration.Default);
var response = accountApi.ForgotUsernamePut(new ForgotUsername(
    email: "john@doe.com"
));

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var forgotUsername = new  api.ForgotUsername();

forgotUsername.email = "xxx@gmail.com";
forgotUsername.phoneNumber = "xxx-xxx-xxxx";

accountApi.forgotUsernamePut(forgotUsername).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

api_instance = ClickSendClient::AccountApi.new

opts = {
  forgot_username: ClickSendClient::ForgotUsername.new( # ForgotUsername | ForgotUsername model
    "email": "test@email.com"
  )
}

begin
  # Forgot username
  result = api_instance.forgot_username_put(opts)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->forgot_username_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# create an instance of the API class
api_instance = clicksend_client.AccountApi()
forgot_username = clicksend_client.ForgotUsername(
                  email='xxx@gmail.com',
                  phone_number= '000-000-0000') # ForgotUsername |  (optional)

try:
    # Forgot username
    api_response = api_instance.forgot_username_put(forgot_username=forgot_username)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->forgot_username_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $api         = WWW::ClickSendClient::AccountApi->new();
my $email       = 'YOUR_EMAIL';

my $json_output = $api->forgot_username_put('email' => $email);

print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];
CSForgotUsername *forgotUserName = [[CSForgotUsername alloc] init];
forgotUserName.email = @"johndoe1@gmail.com";
forgotUserName.phoneNumber = @"3108147982";

[accountAPI forgotUsernamePutWithForgotUsername:forgotUserName completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"%@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let forgotUserName = ForgotUsername(
    email: "johndoe1@gmail.com", 
    phoneNumber: "3108147982"
)

AccountAPI.forgotUsernamePut(forgotUsername: forgotUserName) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}

    Coming Soon

package ClickSend;

import ClickSend.Api.AccountApi;
import ClickSend.Model.ForgotUsername;

public class forgot_username {
  public static void main(String[] args) {
    ApiClient defaultClient = new ApiClient();
    defaultClient.setUsername("USERNAME");
    defaultClient.setPassword("API_KEY");
    AccountApi apiInstance = new AccountApi(defaultClient);
    ForgotUsername forgotUsername = new ForgotUsername(); // ForgotUsername | 
    forgotUsername.email("xxx@gmail.com");
    forgotUsername.phoneNumber("xxx-xxx-xxxx");
    try {
        String result = apiInstance.forgotUsernamePut(forgotUsername);
        System.out.println(result);
    } catch (ApiException e) {
        System.err.println("Exception when calling AccountApi#forgotUsernamePut");
        e.printStackTrace();
    }
  }
}

{
  "phone_number": "3108147982",
  "email": "test@email.com"
}

{
  "http_code": 200,
  "response_code": "SUCCESS",
  "response_msg": "An email notification has been sent.",
  "data": []
}

curl --include \
     --request PUT \
     --header "Content-Type: application/json" \
     --data-binary "    {
        \"username\": \"0F6pKiiuca\"
    }" \
'https://rest.clicksend.com/v3/forgot-password'

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: BasicAuth
$config = ClickSend\Configuration::getDefaultConfiguration()
              ->setUsername('USERNAME')
              ->setPassword('API_KEY');

$apiInstance = new ClickSend\Api\AccountApi(new GuzzleHttp\Client(),$config);
$forgot_password = new \ClickSend\Model\ForgotPassword(); // \ClickSend\Model\ForgotPassword | 
$forgot_password->username="username";

try {
    $result = $apiInstance->forgotPasswordPut($forgot_password);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->forgotPasswordPut: ', $e->getMessage(), PHP_EOL;
}
?>

using IO.ClickSend.ClickSend.Api;
using IO.ClickSend.Client;

var accountApi = new AccountApi(Configuration.Default);
var response = accountApi.ForgotPasswordPut(USERNAME);

var api = require('./api.js');

var accountApi = new api.AccountApi("USERNAME", "API_KEY");

var forgotPassword = new  api.ForgotPassword();

forgotPassword.username = "xxx@gmail.com";

accountApi.forgotPasswordPut(forgotPassword).then(function(response) {
  console.log(response.body);
}).catch(function(err){
  console.error(err.body);
});

# load the gem
require 'clicksend_client'
require 'json'

# setup authorization
ClickSendClient.configure do |config|
  # Configure HTTP basic authorization: BasicAuth
  config.username = 'USERNAME'
  config.password = 'API_KEY'
end

api_instance = ClickSendClient::AccountApi.new

# ForgotPassword |
opts = {
  forgot_password: ClickSendClient::ForgotPassword.new(
    "username": "0F6pKiiuca"
  )
}

begin
  # Forgot password
  result = api_instance.forgot_password_put(opts)
  p JSON.parse(result)
rescue ClickSendClient::ApiError => e
  puts "Exception when calling AccountApi->forgot_password_put: #{e.response_body}"
end

from __future__ import print_function
import clicksend_client
from clicksend_client.rest import ApiException

# Configure HTTP basic authorization: BasicAuth
configuration = clicksend_client.Configuration()
configuration.username = 'USERNAME'
configuration.password = 'API_KEY'

# create an instance of the API class
api_instance = clicksend_client.AccountApi(clicksend_client.ApiClient(configuration))
forgot_password = clicksend_client.ForgotPassword(username='USERNAME') # ForgotPassword |  (optional)

try:
    # Forgot password
    api_response = api_instance.forgot_password_put(forgot_password=forgot_password)
    print(api_response)
except ApiException as e:
    print("Exception when calling AccountApi->forgot_password_put: %s\n" % e)

use WWW::ClickSendClient::AccountApi;

my $api = WWW::ClickSendClient::AccountApi->new();

my $username = 'YOUR_USER_NAME';

my $json_output = $api->forgot_password_put('username' => $username);
print $json_output;

#import "CSDefaultConfiguration.h"
#import "CSAccountApi.h"

CSDefaultConfiguration *apiConfig = [CSDefaultConfiguration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"USERNAME"];
[apiConfig setPassword:@"PASSWORD"];

CSAccountApi *accountAPI = [[CSAccountApi alloc] init];

CSForgotPassword *forgotPassword = [[CSForgotPassword alloc] init];
forgotPassword.username = @"USERNAME";

[accountAPI forgotPasswordPutWithForgotPassword:forgotPassword completionHandler:^(NSString *output, NSError *error) {
    if (error) {
        NSLog(@"Error: %@", error);
    } else {
        NSLog(@"%@", output);
    }
}];

import Alamofire

if let authHeader = Request.authorizationHeader(user: "USERNAME", password: "PASSWORD") {
    ClickSendClientAPI.customHeaders = [authHeader.key : authHeader.value]
}

let forgotPassword = ForgotPassword(username: "USERNAME")

AccountAPI.forgotPasswordPut(forgotPassword: forgotPassword) { (dataString, error) in
    guard let dataString = dataString else {
        print(error!)
        return
    }

    if let data = dataString.data(using: String.Encoding.utf8) {
        do {
            if let dictonary = try (JSONSerialization.jsonObject(with: data, options: []) as? NSDictionary) {
                print(dictonary)
            } else {
                print("Cannot convert the String value to JSON")
            }
        } catch let error as NSError {
            print(error)
        }
    }
}