Introduction

Our HTTP REST API allows you to manage vital details of your account and services in client portal. JSON is used for all API returns

Use left menu to browse trough available methods, use right menu to check required parameters, data to post and code samples in various languages.

Swagger Doc: You can download or display the JSON to generate documentation in Swagger.

Authentication

JSON Web Token Authentication

curl 'https://my.bkns.net/api/login' \
    -d username="username"\
    -d password="password"

# grab authentication token from the response and pass it in Authorization header
curl 'https://my.bkns.net/api/details' \
    -H "Authorization: Bearer $token"

$resp = $client->post('login', [
    'form_params' => [
        'username' => 'username',
        'password' => 'password'
    ]
]);

$token = $resp->json()['token'];

$resp = $client->get('details', [
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

echo $resp->getBody();

payload = username
resp = requests.post('https://my.bkns.net/api/login', data=payload)

headers = {
    'Authorization': 'Bearer ' + req.json().token
}
resp = requests.get('https://my.bkns.net/api/details', headers=headers)
print(resp)

To authenticate, you need to send a JSON Web Token (JWT) in the authorization header of the HTTP request.

To obtain the authorization token you need to submit a request with your username and password to POST https://my.bkns.net/api/login API method

All API calls that require authentication expect HTTP header in the form of Authorization: Bearer <token>.

For example:
Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc...

Basic Authentication

# pass the correct header with each request (-u option)
curl 'https://my.bkns.net/api/details' \
    -u "username:password"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'auth' => ['username', 'password']
]);

$resp = $client->get('details');

# python requests module handles basic authentication if provided with auth parameter
payload = username
req = requests.get('https://my.bkns.net/api/details', auth=('username', 'password'))
print(req.json())

This authentication method requires that you send your client area username (email address) and password with each request.

API calls that require authentication expect a header in the form of Authorization: Basic <credentials>, where credentials is the Base64 encoding of username and password joined by a single colon :.

For example:
Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

You can find more info on this authentication method here: Basic HTTP Authentication

You must replace QWxhZGRpbjpvcGVuIHNlc2FtZQ== with base64 encoded version of your access details.

Clientarea

Generate new authorization token

POST_DATA="{
    \"username\": \"user@example.com\",
    \"password\": \"secret\"
}"

curl -X POST "https://my.bkns.net/api/login" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "username" => "user@example.com",
        "password" => "secret"
    ]
]
$resp = $client->post('login', $options);
echo $resp->getBody();

payload = {
    'username': "user@example.com",
    'password': "secret"
}


req = requests.post('https://my.bkns.net/api/login', json=payload)
print(req.json())

{
    "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJodHRwOlwvXC9yZXBvY2(...)xlYW4uaJleHAiOjE2MTM4MTg3NjV9.qaslo9KnbBVNIkyNwG2mLQlFGkpNdBAwV1IY"
    
}

HTTP Request

POST /login

Query Parameters

Parameter	Type	Description
username	`string`	Your acount email address
password	`string`	Account password

Logout

Invalidate authorization token


curl -X POST "https://my.bkns.net/api/logout" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('logout');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/logout', headers=headers)
print(req.json())

{
    "status": true
}

HTTP Request

POST /logout

Refresh Token

Generate new authorization token using refresh token

POST_DATA="{
    \"refresh_token\": \"refresh_tokenValue\"
}"

curl -X POST "https://my.bkns.net/api/token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "refresh_token" => "refresh_tokenValue"
    ]
]
$resp = $client->post('token', $options);
echo $resp->getBody();

payload = {
    'refresh_token': "refresh_tokenValue"
}


req = requests.post('https://my.bkns.net/api/token', json=payload)
print(req.json())

{
    "token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJodHR(...)vY2xlYiHGvauCWZD9B0VwXgHEzXDllqY",
    "refresh": "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJBQ(...)Rmivc_u3YA_kgDqOPtUuGNXOzueXYtZw"
}

HTTP Request

POST /token

Query Parameters

Parameter	Type	Description
refresh_token	`string`	Refresh token previously obtained from `POST /login`

Revoke Token

Invalidate authorization and refresh token. Pass refresh token or call this method with valid access token

POST_DATA="{
    \"refresh_token\": \"refresh_tokenValue\"
}"

curl -X POST "https://my.bkns.net/api/revoke" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "refresh_token" => "refresh_tokenValue"
    ]
]
$resp = $client->post('revoke', $options);
echo $resp->getBody();

payload = {
    'refresh_token': "refresh_tokenValue"
}


req = requests.post('https://my.bkns.net/api/revoke', json=payload)
print(req.json())

{
    "status": true
}

HTTP Request

POST /revoke

Query Parameters

Parameter	Type	Description
refresh_token	`string`

Create new account

POST_DATA="{
    \"type\": \"typeValue\",
    \"companyname\": \"companynameValue\",
    \"taxid\": \"taxidValue\",
    \"gender\": \"genderValue\",
    \"lastname\": \"lastnameValue\",
    \"firstname\": \"firstnameValue\",
    \"email\": \"emailValue\",
    \"phonenumber\": \"phonenumberValue\",
    \"zalonumber\": \"zalonumberValue\",
    \"nationalid\": \"nationalidValue\",
    \"birthday\": \"birthdayValue\",
    \"country\": \"countryValue\",
    \"state\": \"stateValue\",
    \"city\": \"cityValue\",
    \"ward\": \"wardValue\",
    \"address1\": \"address1Value\",
    \"password\": \"passwordValue\",
    \"currency\": \"currencyValue\"
}"

curl -X POST "https://my.bkns.net/api/signup" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "type" => "typeValue",
        "companyname" => "companynameValue",
        "taxid" => "taxidValue",
        "gender" => "genderValue",
        "lastname" => "lastnameValue",
        "firstname" => "firstnameValue",
        "email" => "emailValue",
        "phonenumber" => "phonenumberValue",
        "zalonumber" => "zalonumberValue",
        "nationalid" => "nationalidValue",
        "birthday" => "birthdayValue",
        "country" => "countryValue",
        "state" => "stateValue",
        "city" => "cityValue",
        "ward" => "wardValue",
        "address1" => "address1Value",
        "password" => "passwordValue",
        "currency" => "currencyValue"
    ]
]
$resp = $client->post('signup', $options);
echo $resp->getBody();

payload = {
    'type': "typeValue",
    'companyname': "companynameValue",
    'taxid': "taxidValue",
    'gender': "genderValue",
    'lastname': "lastnameValue",
    'firstname': "firstnameValue",
    'email': "emailValue",
    'phonenumber': "phonenumberValue",
    'zalonumber': "zalonumberValue",
    'nationalid': "nationalidValue",
    'birthday': "birthdayValue",
    'country': "countryValue",
    'state': "stateValue",
    'city': "cityValue",
    'ward': "wardValue",
    'address1': "address1Value",
    'password': "passwordValue",
    'currency': "currencyValue"
}


req = requests.post('https://my.bkns.net/api/signup', json=payload)
print(req.json())

{
    "info": [
        "client_registered"
    ]
}

HTTP Request

POST /signup

Query Parameters

Parameter	Type	Description
type	`string`	Account Type Available values: `Private`, `Company`. *Required*
companyname	`string`	Organization *Required for organization account*
taxid	`string`	Mã số thuế *Required for organization account*
gender	`string`	gender Available values: `Male`, `Female`.
lastname	`string`	Last Name
firstname	`string`	First Name *Required*
email	`string`	Email Address *Required*
phonenumber	`string`	Phone *Required*
zalonumber	`string`	Zalo - Số điện thoại sử dụng Zalo Nếu quý khách đồng ý nhận thông báo dịch vụ hết hạn, hoá đơn qua tin nhắn Zalo
nationalid	`string`	CCCD/Passport *Required*
birthday	`string`	Ngày sinh (ngày-tháng-năm)
country	`string`	Country *Required*
state	`string`	State *Required*
city	`string`	City *Required*
ward	`string`	Xã/Phường *Required*
address1	`string`	Address 1 *Required*
password	`string`	Password *Required*
currency	`string`	Currency Available values: `VND`, `USD`.

User Details

Return registration details for my account


curl -X GET "https://my.bkns.net/api/details" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('details');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/details', headers=headers)
print(req.json())

{
    "client": {
        "id": "26",
        "email": "api@example.com",
        "lastlogin": "2016-12-30 12:24:28",
        "ip": "172.100.2.1",
        "host": "hostname",
        "firstname": "Joe",
        "lastname": "Doe",
        "companyname": "",
        "address1": "Pretty View Lane",
        "address2": "3294",
        "city": "Santa Rosa",
        "state": "California",
        "postcode": "95401",
        "country": "US",
        "phonenumber": "+1.24123123"
    }
}

HTTP Request

GET /details

User Logs

Returns logs from history


curl -X GET "https://my.bkns.net/api/logs" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('logs');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/logs', headers=headers)
print(req.json())

HTTP Request

GET /logs

Get Affiliate summary


curl -X GET "https://my.bkns.net/api/affiliates/summary" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('affiliates/summary');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/affiliates/summary', headers=headers)
print(req.json())

HTTP Request

GET /affiliates/summary

Get Affiliate campaigns


curl -X GET "https://my.bkns.net/api/affiliates/campaigns" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('affiliates/campaigns');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/affiliates/campaigns', headers=headers)
print(req.json())

HTTP Request

GET /affiliates/campaigns

Get Affiliate commissions


curl -X GET "https://my.bkns.net/api/affiliates/commissions" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('affiliates/commissions');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/affiliates/commissions', headers=headers)
print(req.json())

HTTP Request

GET /affiliates/commissions

Get Affiliate payouts


curl -X GET "https://my.bkns.net/api/affiliates/payouts" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('affiliates/payouts');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/affiliates/payouts', headers=headers)
print(req.json())

HTTP Request

GET /affiliates/payouts

Get Affiliate vouchers


curl -X GET "https://my.bkns.net/api/affiliates/vouchers" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('affiliates/vouchers');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/affiliates/vouchers', headers=headers)
print(req.json())

HTTP Request

GET /affiliates/vouchers

Get Affiliate commission plans


curl -X GET "https://my.bkns.net/api/affiliates/commissionplans" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('affiliates/commissionplans');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/affiliates/commissionplans', headers=headers)
print(req.json())

HTTP Request

GET /affiliates/commissionplans

List contacts

Return a list of contacts on this account


curl -X GET "https://my.bkns.net/api/contact" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('contact');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/contact', headers=headers)
print(req.json())

{
    "contacts": [
        {
            "email": "mary@example.com",
            "id": "49",
            "firstname": "Mary",
            "lastname": "Sue",
            "companyname": "",
            "company": "0",
            "lastlogin": "0000-00-00 00:00:00"
        }
    ]
}

HTTP Request

GET /contact

Add contact

Create new contact account, if password is provided you can use provided email addres to login as that contact.

POST_DATA="{
    \"password\": \"passwordValue\",
    \"privileges\": \"privilegesValue\",
    \"type\": \"typeValue\",
    \"companyname\": \"companynameValue\",
    \"taxid\": \"taxidValue\",
    \"gender\": \"genderValue\",
    \"lastname\": \"lastnameValue\",
    \"firstname\": \"firstnameValue\",
    \"email\": \"emailValue\",
    \"phonenumber\": \"phonenumberValue\",
    \"zalonumber\": \"zalonumberValue\",
    \"nationalid\": \"nationalidValue\",
    \"birthday\": \"birthdayValue\",
    \"country\": \"countryValue\",
    \"state\": \"stateValue\",
    \"city\": \"cityValue\",
    \"ward\": \"wardValue\",
    \"address1\": \"address1Value\",
    \"postcode\": \"postcodeValue\",
    \"telegramnotifications\": \"telegramnotificationsValue\",
    \"zalonotifications\": \"zalonotificationsValue\"
}"

curl -X POST "https://my.bkns.net/api/contact" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "password" => "passwordValue",
        "privileges" => "privilegesValue",
        "type" => "typeValue",
        "companyname" => "companynameValue",
        "taxid" => "taxidValue",
        "gender" => "genderValue",
        "lastname" => "lastnameValue",
        "firstname" => "firstnameValue",
        "email" => "emailValue",
        "phonenumber" => "phonenumberValue",
        "zalonumber" => "zalonumberValue",
        "nationalid" => "nationalidValue",
        "birthday" => "birthdayValue",
        "country" => "countryValue",
        "state" => "stateValue",
        "city" => "cityValue",
        "ward" => "wardValue",
        "address1" => "address1Value",
        "postcode" => "postcodeValue",
        "telegramnotifications" => "telegramnotificationsValue",
        "zalonotifications" => "zalonotificationsValue"
    ]
]
$resp = $client->post('contact', $options);
echo $resp->getBody();

payload = {
    'password': "passwordValue",
    'privileges': "privilegesValue",
    'type': "typeValue",
    'companyname': "companynameValue",
    'taxid': "taxidValue",
    'gender': "genderValue",
    'lastname': "lastnameValue",
    'firstname': "firstnameValue",
    'email': "emailValue",
    'phonenumber': "phonenumberValue",
    'zalonumber': "zalonumberValue",
    'nationalid': "nationalidValue",
    'birthday': "birthdayValue",
    'country': "countryValue",
    'state': "stateValue",
    'city': "cityValue",
    'ward': "wardValue",
    'address1': "address1Value",
    'postcode': "postcodeValue",
    'telegramnotifications': "telegramnotificationsValue",
    'zalonotifications': "zalonotificationsValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/contact', json=payload, headers=headers)
print(req.json())

{
    "contact_id": "1",        
    "info": [
        "profile_added"
    ]
}

HTTP Request

POST /contact

Query Parameters

Parameter	Type	Description
password	`string`	Optional, allows you to login as contact
privileges	`array`	Array with privileges that you want to enable. Formatted the same way as output from `GET /contact/privileges`
type	`string`	Account Type Available values: `Private`, `Company`.
companyname	`string`	Organization
taxid	`string`	Mã số thuế
gender	`string`	gender Available values: `Male`, `Female`.
lastname	`string`	Last Name
firstname	`string`	First Name
email	`string`	Email Address
phonenumber	`string`	Phone
zalonumber	`string`	Zalo - Số điện thoại sử dụng Zalo Nếu quý khách đồng ý nhận thông báo dịch vụ hết hạn, hoá đơn qua tin nhắn Zalo
nationalid	`string`	CCCD/Passport
birthday	`string`	Ngày sinh (ngày-tháng-năm)
country	`string`	Country
state	`string`	State
city	`string`	City
ward	`string`	Xã/Phường
address1	`string`	Address 1
postcode	`string`	Post code
telegramnotifications	`string[]`	Telegram Available values: `Yes`.
zalonotifications	`string[]`	Tắt thông báo Zalo - Mặc định quý khách sẽ nhận được thông báo hoá đơn qua Zalo, trong trường hợp quý khách không muốn nhận thông báo, quý khách có thể Tick chọn để tắt Available values: `Yes`.

Contact privileges

List possible contact privileges. Each domain and service may list additional privileges, depending on available features.


curl -X GET "https://my.bkns.net/api/contact/privileges" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('contact/privileges');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/contact/privileges', headers=headers)
print(req.json())

{
    "privileges": {
        "billing": [
            "emails", // Receive billing notifications
            "payinvoice", // Allow to view/pay invoices
            "orders", // Allow to place new orders
            "balance", // View account balance
            "addfunds", // Add account funds
            "creditcard" // Edit Credit Card details
        ],
        "support": [
            "newticket", // Open new tickets
            "tickets", // View all tickets
            "closeticket", // Close tickets
            "emails" // Receive email notifications from support
        ],
        "misc": [
            "editmain", // Modify main profile details
            "emails", // View emails history
            "editipaccess", // Edit allowed IP access
            "manageprofiles", // Add / Edit contacts
            "affiliates" // Access affiliates section
        ],
        "services": {
            "full": 1, // Full control over services
            "332": [
                "basic", // View basic details
                "billing", // View billing info
                "cancelation", // Request cancellation
                "upgrade", // Upgrade / Downgrade
                "notify", // Receive related email notifications	
                (...)
                "logindetails"
            ]
        },
        "domains": {
            "full": 1, // Full control over domains
            "523": [
                "basic", // View basic details
                "renew", // Renew domain
                "notify", // Receive related email notifications	
                "contactinfo", // Contact Information
                (...)
                "nameservers" // Manage Nameservers
            ]
        }
    }
}

HTTP Request

GET /contact/privileges

Get contacts details

Return array with contact details


curl -X GET "https://my.bkns.net/api/contact/@id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('contact/@id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/contact/@id', headers=headers)
print(req.json())

{
    "contact": {
        "id": "49",
        "email": "mary@example.com",
        "firstname": "Mary",
        "lastname": "Sue",
        "companyname": "",
        "address1": "Pretty View Lane",
        "address2": "3194",
        "city": "Santa Rosa",
        "state": "California",
        "postcode": "95401",
        "country": "US",
        "phonenumber": "+1.24123123",
        "type": "Private",
        "privileges" : {
            "support" : ["tickets", "newticket"]
        }
    }
}

HTTP Request

GET /contact/@id

Query Parameters

Parameter	Type	Description
id	`int`	Contact ID

Edit contact

Change contact details`

POST_DATA="{
    \"privileges\": \"privilegesValue\",
    \"type\": \"typeValue\",
    \"companyname\": \"companynameValue\",
    \"taxid\": \"taxidValue\",
    \"gender\": \"genderValue\",
    \"lastname\": \"lastnameValue\",
    \"firstname\": \"firstnameValue\",
    \"email\": \"emailValue\",
    \"phonenumber\": \"phonenumberValue\",
    \"zalonumber\": \"zalonumberValue\",
    \"nationalid\": \"nationalidValue\",
    \"birthday\": \"birthdayValue\",
    \"country\": \"countryValue\",
    \"state\": \"stateValue\",
    \"city\": \"cityValue\",
    \"ward\": \"wardValue\",
    \"address1\": \"address1Value\",
    \"postcode\": \"postcodeValue\",
    \"telegramnotifications\": \"telegramnotificationsValue\",
    \"zalonotifications\": \"zalonotificationsValue\"
}"

curl -X PUT "https://my.bkns.net/api/contact/@id" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "privileges" => "privilegesValue",
        "type" => "typeValue",
        "companyname" => "companynameValue",
        "taxid" => "taxidValue",
        "gender" => "genderValue",
        "lastname" => "lastnameValue",
        "firstname" => "firstnameValue",
        "email" => "emailValue",
        "phonenumber" => "phonenumberValue",
        "zalonumber" => "zalonumberValue",
        "nationalid" => "nationalidValue",
        "birthday" => "birthdayValue",
        "country" => "countryValue",
        "state" => "stateValue",
        "city" => "cityValue",
        "ward" => "wardValue",
        "address1" => "address1Value",
        "postcode" => "postcodeValue",
        "telegramnotifications" => "telegramnotificationsValue",
        "zalonotifications" => "zalonotificationsValue"
    ]
]
$resp = $client->put('contact/@id', $options);
echo $resp->getBody();

payload = {
    'privileges': "privilegesValue",
    'type': "typeValue",
    'companyname': "companynameValue",
    'taxid': "taxidValue",
    'gender': "genderValue",
    'lastname': "lastnameValue",
    'firstname': "firstnameValue",
    'email': "emailValue",
    'phonenumber': "phonenumberValue",
    'zalonumber': "zalonumberValue",
    'nationalid': "nationalidValue",
    'birthday': "birthdayValue",
    'country': "countryValue",
    'state': "stateValue",
    'city': "cityValue",
    'ward': "wardValue",
    'address1': "address1Value",
    'postcode': "postcodeValue",
    'telegramnotifications': "telegramnotificationsValue",
    'zalonotifications': "zalonotificationsValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/contact/@id', json=payload, headers=headers)
print(req.json())

{
    "info": [
        "profile_updated"
    ]
}

HTTP Request

PUT /contact/@id

Query Parameters

Parameter	Type	Description
id	`int`
privileges	`array`	Array with privileges that you want to enable. Formatted the same way as output from `GET /contact/privileges`
type	`string`	Account Type Available values: `Private`, `Company`.
companyname	`string`	Organization
taxid	`string`	Mã số thuế
gender	`string`	gender Available values: `Male`, `Female`.
lastname	`string`	Last Name
firstname	`string`	First Name
email	`string`	Email Address
phonenumber	`string`	Phone
zalonumber	`string`	Zalo - Số điện thoại sử dụng Zalo Nếu quý khách đồng ý nhận thông báo dịch vụ hết hạn, hoá đơn qua tin nhắn Zalo
nationalid	`string`	CCCD/Passport
birthday	`string`	Ngày sinh (ngày-tháng-năm)
country	`string`	Country
state	`string`	State
city	`string`	City
ward	`string`	Xã/Phường
address1	`string`	Address 1
postcode	`string`	Post code
telegramnotifications	`string[]`	Telegram Available values: `Yes`.
zalonotifications	`string[]`	Tắt thông báo Zalo - Mặc định quý khách sẽ nhận được thông báo hoá đơn qua Zalo, trong trường hợp quý khách không muốn nhận thông báo, quý khách có thể Tick chọn để tắt Available values: `Yes`.

List all portal notifications

Return a list of all portal notifications.


curl -X GET "https://my.bkns.net/api/notifications" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('notifications');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/notifications', headers=headers)
print(req.json())

HTTP Request

GET /notifications

Query Parameters

Parameter	Type	Description
rel_type	`string`	Optional, return only by relation type
rel_id	`string`	Optional, return only by relation id

List new portal notifications

Return only new portal notifications.


curl -X GET "https://my.bkns.net/api/notifications/new" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('notifications/new');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/notifications/new', headers=headers)
print(req.json())

HTTP Request

GET /notifications/new

Query Parameters

Parameter	Type	Description
rel_type	`string`	Optional, return only by relation type
rel_id	`string`	Optional, return only by relation id

Acknowledge notification

Marks the notification as read


curl -X PUT "https://my.bkns.net/api/notifications/@id/ack" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('notifications/@id/ack');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/notifications/@id/ack', headers=headers)
print(req.json())

HTTP Request

PUT /notifications/@id/ack

Query Parameters

Parameter	Type	Description
id	`int`

Returns a list of all statuses with specific status


curl -X GET "https://my.bkns.net/api/statuses" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('statuses');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/statuses', headers=headers)
print(req.json())

HTTP Request

GET /statuses

Query Parameters

Parameter	Type	Description
status	`string`

Returns details of status


curl -X PUT "https://my.bkns.net/api/statuses/@id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('statuses/@id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/statuses/@id', headers=headers)
print(req.json())

HTTP Request

PUT /statuses/@id

Query Parameters

Parameter	Type	Description
id	`int`

OCR Recognition

Get a list of all documents.

POST_DATA="{
    \"request_id\": \"idValue\",
    \"image\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/ekyc/ocr/recognition" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "request_id" => "idValue",
        "image" => "idValue"
    ]
]
$resp = $client->post('ekyc/ocr/recognition', $options);
echo $resp->getBody();

payload = {
    'request_id': "idValue",
    'image': "idValue"
}


req = requests.post('https://my.bkns.net/api/ekyc/ocr/recognition', json=payload)
print(req.json())

HTTP Request

POST /ekyc/ocr/recognition

Query Parameters

Parameter	Type	Description
request_id	`string`	Request id
image	`string`	Imagr card

Faceid verification

Get a list of all documents.

POST_DATA="{
    \"request_id\": \"idValue\",
    \"image_live\": \"idValue\",
    \"image_live_1 \": \"idValue\",
    \"image_live_2\": \"idValue\",
    \"image_live_3\": \"idValue\",
    \"image_card\": \"idValue\",
    \"domainsid\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/ekyc/faceid/verification" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "request_id" => "idValue",
        "image_live" => "idValue",
        "image_live_1 " => "idValue",
        "image_live_2" => "idValue",
        "image_live_3" => "idValue",
        "image_card" => "idValue",
        "domainsid" => "idValue"
    ]
]
$resp = $client->post('ekyc/faceid/verification', $options);
echo $resp->getBody();

payload = {
    'request_id': "idValue",
    'image_live': "idValue",
    'image_live_1 ': "idValue",
    'image_live_2': "idValue",
    'image_live_3': "idValue",
    'image_card': "idValue",
    'domainsid': "idValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/ekyc/faceid/verification', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /ekyc/faceid/verification

Query Parameters

Parameter	Type	Description
request_id	`string`	Request id
image_live	`string`	Live Face Image
image_live_1	`string`	Live Face Image
image_live_2	`string`	Live Face Image
image_live_3	`string`	Live Face Image
image_card	`string`	Image card
domainsid	`string`	domainsid

Faceid verification

Get a list of all documents.

POST_DATA="{
    \"request_id\": \"idValue\",
    \"image_live\": \"idValue\",
    \"image_live_1 \": \"idValue\",
    \"image_live_2\": \"idValue\",
    \"image_live_3\": \"idValue\",
    \"image_card\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/ekyc/faceid/verifications" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "request_id" => "idValue",
        "image_live" => "idValue",
        "image_live_1 " => "idValue",
        "image_live_2" => "idValue",
        "image_live_3" => "idValue",
        "image_card" => "idValue"
    ]
]
$resp = $client->post('ekyc/faceid/verifications', $options);
echo $resp->getBody();

payload = {
    'request_id': "idValue",
    'image_live': "idValue",
    'image_live_1 ': "idValue",
    'image_live_2': "idValue",
    'image_live_3': "idValue",
    'image_card': "idValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/ekyc/faceid/verifications', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /ekyc/faceid/verifications

Query Parameters

Parameter	Type	Description
request_id	`string`	Request id
image_live	`string`	Live Face Image
image_live_1	`string`	Live Face Image
image_live_2	`string`	Live Face Image
image_live_3	`string`	Live Face Image
image_card	`string`	Image card

Get business info


curl -X GET "https://my.bkns.net/api/clientarea/businessinfo"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('clientarea/businessinfo');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/clientarea/businessinfo')
print(req.json())

HTTP Request

GET /clientarea/businessinfo

Query Parameters

Parameter	Type	Description
taxid	`string`

Get gethouseholds info


curl -X GET "https://my.bkns.net/api/clientarea/gethouseholds"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('clientarea/gethouseholds');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/clientarea/gethouseholds')
print(req.json())

HTTP Request

GET /clientarea/gethouseholds

Query Parameters

Parameter	Type	Description
taxid	`string`

Get emailloginbkns info

email login bkns


curl -X GET "https://my.bkns.net/api/clientarea/emailloginbkns"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('clientarea/emailloginbkns');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/clientarea/emailloginbkns')
print(req.json())

HTTP Request

GET /clientarea/emailloginbkns

Query Parameters

Parameter	Type	Description
name	`string`

Billing

Account balance

Get current account balance(unpaid invoices total), account credit


curl -X GET "https://my.bkns.net/api/balance" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('balance');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/balance', headers=headers)
print(req.json())

{
    {
        "success": true,
        "details": {
            "currency": "USD",
            "acc_balance": "123456.55",
            "acc_credit": "0.00"
        }
    }
}

HTTP Request

GET /balance

Apply credit

Apply account credit to invoice

POST_DATA="{
    \"amount\": \"amountValue\"
}"

curl -X POST "https://my.bkns.net/api/invoice/@id/credit" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "amount" => "amountValue"
    ]
]
$resp = $client->post('invoice/@id/credit', $options);
echo $resp->getBody();

payload = {
    'amount': "amountValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/invoice/@id/credit', json=payload, headers=headers)
print(req.json())

{
    "success": true,
    "invoice_status": "Paid",
    "applied": 2.1
}

HTTP Request

POST /invoice/@id/credit

Query Parameters

Parameter	Type	Description
id	`int`
amount	`number`	Optional credit amount, when no value is specified maximum amount to fully pay the invoice will be used

Payment Methods

List available payment methods


curl -X GET "https://my.bkns.net/api/payment" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('payment');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/payment', headers=headers)
print(req.json())

{
    "payments": {
        "10": "BankTransfer",
        "9": "PayPal"
    }
}

HTTP Request

GET /payment

Payment Methods Fees

List available payment methods with fees


curl -X GET "https://my.bkns.net/api/payment/fees" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('payment/fees');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/payment/fees', headers=headers)
print(req.json())

{
    "payments": [
        {
            "id": 1,
            "name": "Bank Transfer",
            "fixed_fee": "0.0",
            "percent_fee": "0.0",
        },
        {
            "id": 2,
            "name": "Stripe",
            "fixed_fee": "0.5",
            "percent_fee": "2.9",
        },
        {
            "id": 4,
            "name": "Credit Card",
            "fixed_fee": "0.1",
            "percent_fee": "2.4"
        },
        {
            "id": 5,
            "name": "PayPal",
            "fixed_fee": "0.3",
            "percent_fee": "2.9"
        }
    ]
}

HTTP Request

GET /payment/fees

Support

Create Ticket

Submit new ticket

POST_DATA="{
    \"dept_id\": 1,
    \"subject\": \"Subject\",
    \"body\": \"Message ...\"
}"

curl -X POST "https://my.bkns.net/api/tickets" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "dept_id" => 1,
        "subject" => "Subject",
        "body" => "Message ..."
    ]
]
$resp = $client->post('tickets', $options);
echo $resp->getBody();

payload = {
    'dept_id': 1,
    'subject': "Subject",
    'body': "Message ..."
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/tickets', json=payload, headers=headers)
print(req.json())

{
    "ticket": 865650
}

HTTP Request

POST /tickets

Query Parameters

Parameter	Type	Description
dept_id	`int`	Department id
subject	`string`	Ticket subject
body	`string`	Ticket message

Create Reply

Reply to ticket

POST_DATA="{
    \"body\": \"reply text ..\"
}"

curl -X POST "https://my.bkns.net/api/tickets/@number" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "body" => "reply text .."
    ]
]
$resp = $client->post('tickets/@number', $options);
echo $resp->getBody();

payload = {
    'body': "reply text .."
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/tickets/@number', json=payload, headers=headers)
print(req.json())

{
    "info": [
        "reply_added"
    ]
}

HTTP Request

POST /tickets/@number

Query Parameters

Parameter	Type	Description
number	`int`	Ticket number
body	`string`	Reply message

Re-open ticket

Try to re-open closed ticket


curl -X PUT "https://my.bkns.net/api/tickets/@number/open" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('tickets/@number/open');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/tickets/@number/open', headers=headers)
print(req.json())

{
    "status": true
}

HTTP Request

PUT /tickets/@number/open

Query Parameters

Parameter	Type	Description
number	`int`	Ticket number

Close ticket

Send request to close a ticket


curl -X PUT "https://my.bkns.net/api/tickets/@number/close" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('tickets/@number/close');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/tickets/@number/close', headers=headers)
print(req.json())

{
    "status": true
}

HTTP Request

PUT /tickets/@number/close

Query Parameters

Parameter	Type	Description
number	`int`	Ticket number

Ticket attachment

Get ticket attachment


curl -X GET "https://my.bkns.net/api/ticket/attachment/@file" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('ticket/attachment/@file');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/ticket/attachment/@file', headers=headers)
print(req.json())

HTTP Request

GET /ticket/attachment/@file

Query Parameters

Parameter	Type	Description
number	`int`	Ticket number
file	`string`	Attachment id

List ticket departments

Get the list of ticket departments


curl -X GET "https://my.bkns.net/api/ticket/departments" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('ticket/departments');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/ticket/departments', headers=headers)
print(req.json())

HTTP Request

GET /ticket/departments

Domains

Domain details by name

Get domain details by name


curl -X GET "https://my.bkns.net/api/domain/name/@name" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/name/@name');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/name/@name', headers=headers)
print(req.json())

{
    "details": [
        {
            "id": "47",
            "name": "testname.com",
            "date_created": "2016-12-30",
            "firstpayment": "10.00",
            "recurring_amount": "15.00",
            "period": "1",
            "expires": "2017-12-30",
            "status": "Active",
            "next_due": "2017-12-30",
            "next_invoice": "2017-11-30",
            "idprotection": "0",
            "nameservers": [
                "ns1.example.com",
                "ns2.example.com",
                "ns3.example.com",
                "ns4.example.com"
            ],
            "autorenew": "1"
        },
        {
            "id": "48",
            "name": "testname.com",
            "date_created": "2016-05-30",
            "firstpayment": "10.00",
            "recurring_amount": "15.00",
            "period": "1",
            "expires": "2017-05-30",
            "status": "Expired",
            "next_due": "2017-05-30",
            "next_invoice": "2017-04-30",
            "idprotection": "0",
            "nameservers": [
                "ns1.example.com",
                "ns2.example.com",
                "ns3.example.com",
                "ns4.example.com"
            ],
            "autorenew": "1"
        },
    ]
}

HTTP Request

GET /domain/name/@name

Query Parameters

Parameter	Type	Description
name	`string`	Domain name

Get domain nameservers


curl -X GET "https://my.bkns.net/api/domain/@id/ns" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/ns');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/ns', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/ns

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Update domain nameservers

Change domain nameservers, if $nameservers is left empty, default namesevers will be used

POST_DATA="{
    \"nameservers\": \"nameserversValue\"
}"

curl -X PUT "https://my.bkns.net/api/domain/@id/ns" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "nameservers" => "nameserversValue"
    ]
]
$resp = $client->put('domain/@id/ns', $options);
echo $resp->getBody();

payload = {
    'nameservers': "nameserversValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/ns', json=payload, headers=headers)
print(req.json())

{
    "info": [
        "success_changes_save"
    ]
}

HTTP Request

PUT /domain/@id/ns

Query Parameters

Parameter	Type	Description
id	`int`	Domain id
nameservers	`array`	List of nameservers to use

Register domain nameservers


curl -X POST "https://my.bkns.net/api/domain/@id/reg" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('domain/@id/reg');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/domain/@id/reg', headers=headers)
print(req.json())

HTTP Request

POST /domain/@id/reg

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

List Domains

List domains under your account


curl -X GET "https://my.bkns.net/api/domain" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain', headers=headers)
print(req.json())

{
    "domains": [
        {
            "id": "47",
            "name": "testname.com",
            "expires": "2017-12-30",
            "recurring_amount": "15.00",
            "date_created": "2016-12-30",
            "status": "Active",
            "period": "1",
            "autorenew": "1",
            "daytoexpire": "365"
        }
    ]
}

HTTP Request

GET /domain

Domain details

Get domain details


curl -X GET "https://my.bkns.net/api/domain/@id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id', headers=headers)
print(req.json())

{
    "details": {
        "id": "47",
        "name": "testname.com",
        "date_created": "2016-12-30",
        "firstpayment": "10.00",
        "recurring_amount": "15.00",
        "period": "1",
        "expires": "2017-12-30",
        "status": "Active",
        "next_due": "2017-12-30",
        "next_invoice": "2017-11-30",
        "idprotection": "0",
        "nameservers": [
            "ns1.example.com",
            "ns2.example.com",
            "ns3.example.com",
            "ns4.example.com"
        ],
        "autorenew": "1"
    }
}

HTTP Request

GET /domain/@id

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Get domain EPP Code


curl -X GET "https://my.bkns.net/api/domain/@id/epp" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/epp');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/epp', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/epp

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Synchronize domain


curl -X GET "https://my.bkns.net/api/domain/@id/sync" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/sync');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/sync', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/sync

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Get domain lock


curl -X GET "https://my.bkns.net/api/domain/@id/reglock" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/reglock');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/reglock', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/reglock

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Get domain contact info


curl -X GET "https://my.bkns.net/api/domain/@id/contact" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/contact');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/contact', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/contact

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Update domain contact info


curl -X PUT "https://my.bkns.net/api/domain/@id/contact" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('domain/@id/contact');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/contact', headers=headers)
print(req.json())

HTTP Request

PUT /domain/@id/contact

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Get email forwarding


curl -X GET "https://my.bkns.net/api/domain/@id/emforwarding" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/emforwarding');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/emforwarding', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/emforwarding

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Update email forwarding


curl -X PUT "https://my.bkns.net/api/domain/@id/emforwarding" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('domain/@id/emforwarding');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/emforwarding', headers=headers)
print(req.json())

HTTP Request

PUT /domain/@id/emforwarding

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Update domain forwarding


curl -X PUT "https://my.bkns.net/api/domain/@id/forwarding" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('domain/@id/forwarding');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/forwarding', headers=headers)
print(req.json())

HTTP Request

PUT /domain/@id/forwarding

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Get domain autorenew


curl -X GET "https://my.bkns.net/api/domain/@id/autorenew" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/autorenew');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/autorenew', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/autorenew

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Enable/disable domain autorenew


curl -X PUT "https://my.bkns.net/api/domain/@id/autorenew" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('domain/@id/autorenew');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/autorenew', headers=headers)
print(req.json())

HTTP Request

PUT /domain/@id/autorenew

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Returns the available flags


curl -X GET "https://my.bkns.net/api/domain/@id/dnssec/flags" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/dnssec/flags');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/dnssec/flags', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/dnssec/flags

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Returns the list of DNSSEC keys


curl -X GET "https://my.bkns.net/api/domain/@id/dnssec" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/dnssec');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/dnssec', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/dnssec

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Adds the DNSSEC key


curl -X PUT "https://my.bkns.net/api/domain/@id/dnssec" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('domain/@id/dnssec');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/dnssec', headers=headers)
print(req.json())

HTTP Request

PUT /domain/@id/dnssec

Query Parameters

Parameter	Type	Description
id	`int`	Domain id


curl -X DELETE "https://my.bkns.net/api/domain/@id/dnssec/@key" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->delete('domain/@id/dnssec/@key');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.delete('https://my.bkns.net/api/domain/@id/dnssec/@key', headers=headers)
print(req.json())

HTTP Request

DELETE /domain/@id/dnssec/@key

Query Parameters

Parameter	Type	Description
id	`int`	Domain id
key	`string`

Update domain ID Protection


curl -X PUT "https://my.bkns.net/api/domain/@id/idprotection" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->put('domain/@id/idprotection');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/domain/@id/idprotection', headers=headers)
print(req.json())

HTTP Request

PUT /domain/@id/idprotection

Query Parameters

Parameter	Type	Description
id	`int`	Domain id

Additinal data for TLD

Get additional forms required for some TLDs


curl -X GET "https://my.bkns.net/api/domain/order/@id/form" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/order/@id/form');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/order/@id/form', headers=headers)
print(req.json())

{
    "forms": [
        {
            "type": "domaindnssupport",
            "title": "DNS Management",
            "id": "1424",
            "firstItemId": 9067,
            "description": "",
            "name": "custom[1424][9067]",
            "required": false,
            "multiple": false,
            "config": {
                "enableddefault": 0
            },
            "value": [],
            "textvalue": [],
            "price": 0,
            "recurring_price": 0,
            "setup": 0,
            "prorata_date": null,
            "items": [
                {
                    "title": "",
                    "value": 1,
                    "id": 9067,
                    "price": 4,
                    "setup": 0,
                    "selected": false
                }
            ]
        },
        {
            "type": "select",
            "title": "Language",
            "id": "1755",
            "firstItemId": 10952,
            "description": "",
            "name": "custom[1755]",
            "required": false,
            "multiple": false,
            "config": {
                "conditionals": []
            },
            "value": [],
            "textvalue": [],
            "price": 0,
            "recurring_price": 0,
            "setup": 0,
            "prorata_date": null,
            "items": [
                {
                    "title": "AFR",
                    "value": 1,
                    "id": 10952,
                    "price": 0,
                    "setup": 0,
                    "selected": false
                },
                {
                    "title": "ALB",
                    "value": 1,
                    "id": 10953,
                    "price": 0,
                    "setup": 0,
                    "selected": false
                },
                (...)
            ]
        }
    ]
}

HTTP Request

GET /domain/order/@id/form

Query Parameters

Parameter	Type	Description
tld_id	`int`	TLD ID

Order new domain

Create new order for a domain, please check if requested domain is available first, otherwise your order may get cancelled.

POST_DATA="{
    \"name\": \"example.com\",
    \"years\": \"yearsValue\",
    \"action\": \"actionValue\",
    \"tld_id\": \"tld_idValue\",
    \"pay_method\": \"pay_methodValue\",
    \"epp\": \"eppValue\",
    \"nameservers\": \"nameserversValue\",
    \"registrant\": \"registrantValue\",
    \"admin\": \"adminValue\",
    \"tech\": \"techValue\",
    \"billing\": \"billingValue\",
    \"data\": \"dataValue\",
    \"aff_id\": 55
}"

curl -X POST "https://my.bkns.net/api/domain/order" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "name" => "example.com",
        "years" => "yearsValue",
        "action" => "actionValue",
        "tld_id" => "tld_idValue",
        "pay_method" => "pay_methodValue",
        "epp" => "eppValue",
        "nameservers" => "nameserversValue",
        "registrant" => "registrantValue",
        "admin" => "adminValue",
        "tech" => "techValue",
        "billing" => "billingValue",
        "data" => "dataValue",
        "aff_id" => 55
    ]
]
$resp = $client->post('domain/order', $options);
echo $resp->getBody();

payload = {
    'name': "example.com",
    'years': "yearsValue",
    'action': "actionValue",
    'tld_id': "tld_idValue",
    'pay_method': "pay_methodValue",
    'epp': "eppValue",
    'nameservers': "nameserversValue",
    'registrant': "registrantValue",
    'admin': "adminValue",
    'tech': "techValue",
    'billing': "billingValue",
    'data': "dataValue",
    'aff_id': 55
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/domain/order', json=payload, headers=headers)
print(req.json())

{
    "order_num": 563647679,
    "invoice_id": "308977",
    "total": "10.00",
    "items": {
        "id": "10",
        "type": "Domain Register",
        "name": "test.com",
        "product_id": "3"
    }
}

HTTP Request

POST /domain/order

Query Parameters

Parameter	Type	Description
name	`string`	Domain name
years	`string`	Number of years
action	`string`	register\|transfer
tld_id	`string`	TLD id
pay_method	`int`	Payment method ID
epp	`string`	EPP Transfer code, required when transfering some domains
nameservers	`array`	Optional array with 2 - 4 nameservers that you want to use
registrant	`int`	Optional contact ID to use for registrant contact this domain
admin	`int`	Optional contact ID to use for admin contact this domain
tech	`int`	Optional contact ID to use for tech contact this domain
billing	`int`	Optional contact ID to use for billing contact this domain
data	`array`	Addditional data required for some TLDs
aff_id	`int`	Affiliate ID

Renew domain

Create new renew order for a domain, please check if requested domain is available first, otherwise your order may get cancelled.

POST_DATA="{
    \"years\": \"yearsValue\",
    \"pay_method\": \"pay_methodValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/@id/renew" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "years" => "yearsValue",
        "pay_method" => "pay_methodValue"
    ]
]
$resp = $client->post('domain/@id/renew', $options);
echo $resp->getBody();

payload = {
    'years': "yearsValue",
    'pay_method': "pay_methodValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/domain/@id/renew', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /domain/@id/renew

Query Parameters

Parameter	Type	Description
id	`int`
years	`string`	Number of years
pay_method	`int`	Payment method ID

Available TLDs

List TLDs available for registration and transfer


curl -X GET "https://my.bkns.net/api/domain/order" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/order');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/order', headers=headers)
print(req.json())

{
    "tlds": [
        {
            "id": "6",
            "tld": ".com",
            "periods": [
                {
                    "period": "1",
                    "register": "10.00",
                    "transfer": "0.00",
                    "renew": "15.00",
                    "redemption": "40.00"
                },
                {
                    "period": "2",
                    "register": "20.00",
                    "transfer": "20.00",
                    "renew": "30.00",
                    "redemption": "80.00"
                }
            ]
        },
        (...)
    ]
}

HTTP Request

GET /domain/order

Get whois domain

Get whois domain.


curl -X GET "https://my.bkns.net/api/bkns/whois/@domain"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('bkns/whois/@domain');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/bkns/whois/@domain')
print(req.json())

HTTP Request

GET /bkns/whois/@domain

Query Parameters

Parameter	Type	Description
domain	`string`	Domain name

Get list documents

Get a list of all documents.


curl -X GET "https://my.bkns.net/api/domain/@id/documents" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('domain/@id/documents');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/domain/@id/documents', headers=headers)
print(req.json())

HTTP Request

GET /domain/@id/documents

Query Parameters

Parameter	Type	Description
id	`int`	Domain ID

Download document

Download document. Content-Type: application/pdf will be returned


curl -X GET "https://my.bkns.net/api/domain/@id/documents/@documentid/download"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('domain/@id/documents/@documentid/download');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/domain/@id/documents/@documentid/download')
print(req.json())

HTTP Request

GET /domain/@id/documents/@documentid/download

Query Parameters

Parameter	Type	Description
id	`int`	Domain ID
documentid	`int`	Document ID

View document

View document.


curl -X GET "https://my.bkns.net/api/domain/@id/documents/@documentid/View"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('domain/@id/documents/@documentid/View');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/domain/@id/documents/@documentid/View')
print(req.json())

HTTP Request

GET /domain/@id/documents/@documentid/View

Query Parameters

Parameter	Type	Description
id	`int`	Domain ID
documentid	`int`	Document ID

Upload signed document

Upload signed document.

POST_DATA="{
    \"filename\": \"examplefile.pdf\",
    \"content\": \"contentValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/@id/documents/@documentid/upload" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "filename" => "examplefile.pdf",
        "content" => "contentValue"
    ]
]
$resp = $client->post('domain/@id/documents/@documentid/upload', $options);
echo $resp->getBody();

payload = {
    'filename': "examplefile.pdf",
    'content': "contentValue"
}


req = requests.post('https://my.bkns.net/api/domain/@id/documents/@documentid/upload', json=payload)
print(req.json())

HTTP Request

POST /domain/@id/documents/@documentid/upload

Query Parameters

Parameter	Type	Description
id	`int`	Domain ID
documentid	`int`	Document ID
filename	`string`	File name, for example: myfile.pdf
content	`string`	File content, must be base64 encoded content.

Document Sign

View document signed.


curl -X GET "https://my.bkns.net/api/domain/documents/view/@token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('domain/documents/view/@token');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/domain/documents/view/@token')
print(req.json())

HTTP Request

GET /domain/documents/view/@token

Query Parameters

Parameter	Type	Description
token	`string`	Domain token

Download Document Uploaded

Download document.


curl -X GET "https://my.bkns.net/api/domain/documents/download/uploaded/@token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('domain/documents/download/uploaded/@token');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/domain/documents/download/uploaded/@token')
print(req.json())

HTTP Request

GET /domain/documents/download/uploaded/@token

Query Parameters

Parameter	Type	Description
token	`string`	Domain token

Document Signatured

Signatured upload

POST_DATA="{
    \"token\": \"idValue\",
    \"image\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/documents/signed" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "token" => "idValue",
        "image" => "idValue"
    ]
]
$resp = $client->post('domain/documents/signed', $options);
echo $resp->getBody();

payload = {
    'token': "idValue",
    'image': "idValue"
}


req = requests.post('https://my.bkns.net/api/domain/documents/signed', json=payload)
print(req.json())

HTTP Request

POST /domain/documents/signed

Query Parameters

Parameter	Type	Description
token	`string`	Domain token
image	`string`	Signature value

Get Coupon faceidverifitele

Get a list of all faceidverifitele.

POST_DATA="{
    \"id\": \"idValue\",
    \"domain\": \"idValue\",
    \"nost\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/vnnic/faceidverifitele" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "id" => "idValue",
        "domain" => "idValue",
        "nost" => "idValue"
    ]
]
$resp = $client->post('domain/vnnic/faceidverifitele', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'domain': "idValue",
    'nost': "idValue"
}


req = requests.post('https://my.bkns.net/api/domain/vnnic/faceidverifitele', json=payload)
print(req.json())

HTTP Request

POST /domain/vnnic/faceidverifitele

Query Parameters

Parameter	Type	Description
id	`int`	Contact ID
domain	`string`	domain name
nost	`string`	nost

Get Coupon VNNIC Free for domain .id.vn and .biz.vn

Get a list of all documents.

POST_DATA="{
    \"id\": \"idValue\",
    \"domain\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/vnnic/promocode" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "id" => "idValue",
        "domain" => "idValue"
    ]
]
$resp = $client->post('domain/vnnic/promocode', $options);
echo $resp->getBody();

payload = {
    'id': "idValue",
    'domain': "idValue"
}


req = requests.post('https://my.bkns.net/api/domain/vnnic/promocode', json=payload)
print(req.json())

HTTP Request

POST /domain/vnnic/promocode

Query Parameters

Parameter	Type	Description
id	`int`	Contact ID
domain	`string`	domain name

Ekyc bkns biz.vn

ekyc bkns biz.vn.

POST_DATA="{
    \"request_id\": \"idValue\",
    \"image_live\": \"idValue\",
    \"image_live_1 \": \"idValue\",
    \"image_live_2\": \"idValue\",
    \"image_live_3\": \"idValue\",
    \"image_card\": \"idValue\",
    \"domainsid\": \"idValue\",
    \"request_token\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/ekyc/ekyccode" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "request_id" => "idValue",
        "image_live" => "idValue",
        "image_live_1 " => "idValue",
        "image_live_2" => "idValue",
        "image_live_3" => "idValue",
        "image_card" => "idValue",
        "domainsid" => "idValue",
        "request_token" => "idValue"
    ]
]
$resp = $client->post('domain/ekyc/ekyccode', $options);
echo $resp->getBody();

payload = {
    'request_id': "idValue",
    'image_live': "idValue",
    'image_live_1 ': "idValue",
    'image_live_2': "idValue",
    'image_live_3': "idValue",
    'image_card': "idValue",
    'domainsid': "idValue",
    'request_token': "idValue"
}


req = requests.post('https://my.bkns.net/api/domain/ekyc/ekyccode', json=payload)
print(req.json())

HTTP Request

POST /domain/ekyc/ekyccode

Query Parameters

Parameter	Type	Description
request_id	`string`	Request id
image_live	`string`	Live Face Image
image_live_1	`string`	Live Face Image
image_live_2	`string`	Live Face Image
image_live_3	`string`	Live Face Image
image_card	`string`	Image card
domainsid	`string`	domainsid
request_token	`string`	Request token

Ekycup bkns biz.vn

ekycup bkns biz.vn.

POST_DATA="{
    \"request_token\": \"idValue\",
    \"domainsid\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/ekyc/ekyccodeup" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "request_token" => "idValue",
        "domainsid" => "idValue"
    ]
]
$resp = $client->post('domain/ekyc/ekyccodeup', $options);
echo $resp->getBody();

payload = {
    'request_token': "idValue",
    'domainsid': "idValue"
}


req = requests.post('https://my.bkns.net/api/domain/ekyc/ekyccodeup', json=payload)
print(req.json())

HTTP Request

POST /domain/ekyc/ekyccodeup

Query Parameters

Parameter	Type	Description
request_token	`string`	Request token
domainsid	`string`	domainsid

SSL Certificates

List SSL Certificates

List all ssl services under your account


curl -X GET "https://my.bkns.net/api/certificate" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('certificate');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/certificate', headers=headers)
print(req.json())

{
    "sslservices": [
        {
            "id": "300",
            "domain": "examplename.com",
            "total": "27.85",
            "status": "Pending",
            "billingcycle": "Annually",
            "next_due": "2017-12-30",
            "category": "GoGetSSL",
            "category_url": "gogetssl",
            "name": "Comodo InstantSSL",
            "cert_email": "admin@example.com",
            "cert_status": "",
            "cert_expires": "2017-12-30 13:43:12"
        }
    ]
}

HTTP Request

GET /certificate

Certificate details

Return details for certificate @id


curl -X GET "https://my.bkns.net/api/certificate/@id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('certificate/@id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/certificate/@id', headers=headers)
print(req.json())

{
    "service": {
        "id": "300",
        "date_created": "2016-12-30",
        "domain": "examplename.com",
        "firstpayment": "27.85",
        "total": "27.85",
        "billingcycle": "Annually",
        "next_due": "2017-12-30",
        "next_invoice": "2017-10-31",
        "status": "Pending",
        "label": "",
        "name": "Comodo InstantSSL",
        "cert_status": "",
        "cert_expires": "2017-12-30 13:43:12",
        "csr": "-----BEGIN CERTIFICATE REQUEST----- ...",
        "contacts": {
            "admin": {
                "FName": "Mary",
                "LName": "Sue",
                "City": "Santa Rosa",
                "State": "California",
                "PostalCode": "95401",
                "EmailAddress": "mary@example.com",
                "Country": "US",
                "Address1": "Pretty View Lane",
                "Address2": "3194",
                "Phone": 24123223,
                "OrgName": "n\/a",
                "PreFix": 1,
                "JobTitle": "n\/a"
            },
            "billing": {
                (...)
            },
            "tech": {
                (...)
            }
        },
        "organization": {
            "state": "Texas",
            "country": "US",
            "name": "My Org name",
            "unit": "Dev",
            "locality": "SanAntonio",
            "postalcode": "n\/a",
            "address2": "n\/a",
            "address1": "n\/a",
        },
        "cert_email": "admin@example.com",
        "software": "1"
    }
}

HTTP Request

GET /certificate/@id

Query Parameters

Parameter	Type	Description
id	`int`	Service id

Download certificate

Return X.509 certificate data


curl -X GET "https://my.bkns.net/api/certificate/@id/crt" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('certificate/@id/crt');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/certificate/@id/crt', headers=headers)
print(req.json())

HTTP Request

GET /certificate/@id/crt

Query Parameters

Parameter	Type	Description
id	`int`	Service id

List available certificates

Return a list with certificate available for purchase


curl -X GET "https://my.bkns.net/api/certificate/order" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('certificate/order');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/certificate/order', headers=headers)
print(req.json())

{
    "products": [
        {
            "id": "25",
            "name": "InstantSSL",
            "description": "",
            "periods": [
                {
                    "years": 1,
                    "price": 27.85,
                    "renew": 27.85
                },
                {
                    "years": 2,
                    "price": 48.75,
                    "renew": 48.75
                }
            ],
            "category": "SSL Certificates",
            "category_url": "sslcertificates"
        },
        (...)
    ]
}

HTTP Request

GET /certificate/order

List server software for certificates

Return a list with software IDs required or certificate


curl -X GET "https://my.bkns.net/api/certificate/order/@product_id/software" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('certificate/order/@product_id/software');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/certificate/order/@product_id/software', headers=headers)
print(req.json())

{
    "software": [
        {
            "id": 0,
            "name": "AOL"
        },
        {
            "id": 1,
            "name": "Apache-SSL (Ben-SSL, not Stronghold)"
        },
        (...)
    ]
}

HTTP Request

GET /certificate/order/@product_id/software

Query Parameters

Parameter	Type	Description
product_id	`int`	Certificate product ID

Order new certificates

Create new order for a certificate

POST_DATA="{
    \"product_id\": \"product_idValue\",
    \"csr\": \"example.com\",
    \"years\": \"yearsValue\",
    \"pay_method\": \"pay_methodValue\",
    \"approver_email\": \"approver_emailValue\",
    \"admin\": \"adminValue\",
    \"tech\": \"techValue\",
    \"billing\": \"billingValue\",
    \"organization\": \"organizationValue\",
    \"software\": \"softwareValue\",
    \"data\": \"dataValue\",
    \"aff_id\": 55
}"

curl -X POST "https://my.bkns.net/api/certificate/order" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "product_id" => "product_idValue",
        "csr" => "example.com",
        "years" => "yearsValue",
        "pay_method" => "pay_methodValue",
        "approver_email" => "approver_emailValue",
        "admin" => "adminValue",
        "tech" => "techValue",
        "billing" => "billingValue",
        "organization" => "organizationValue",
        "software" => "softwareValue",
        "data" => "dataValue",
        "aff_id" => 55
    ]
]
$resp = $client->post('certificate/order', $options);
echo $resp->getBody();

payload = {
    'product_id': "product_idValue",
    'csr': "example.com",
    'years': "yearsValue",
    'pay_method': "pay_methodValue",
    'approver_email': "approver_emailValue",
    'admin': "adminValue",
    'tech': "techValue",
    'billing': "billingValue",
    'organization': "organizationValue",
    'software': "softwareValue",
    'data': "dataValue",
    'aff_id': 55
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/certificate/order', json=payload, headers=headers)
print(req.json())

{
    "order_num": 873340994,
    "invoice_id": "308978",
    "total": "27.85",
    "items": {
        "id": "10",
        "type": "Hosting",
        "name": "test.com",
        "product_id": "3"
    }
}

HTTP Request

POST /certificate/order

Query Parameters

Parameter	Type	Description
product_id	`int`	Certificate product ID
csr	`string`	Domain name
years	`int`	Number of years
pay_method	`int`	Payment method ID
approver_email	`string`	Email addres used in domain validation
admin	`int`	Admin contact ID
tech	`int`	Tech contact ID
billing	`int`	Billing contact ID
organization	`array`	Organization details
software	`int`	Server/Software ID
data	`array`	Addditional data required for some products
aff_id	`int`	Affiliate ID

Services

List service methods

List methods available for service


curl -X GET "https://my.bkns.net/api/service/@id/methods" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/methods');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/methods', headers=headers)
print(req.json())

{
    "methods": [
        {
            "name": "Upgrade Request",
            "method": "POST",
            "route": "\/service\/@id\/upgrade"
        },
        {
            "name": "Upgrade Options",
            "method": "GET",
            "route": "\/service\/@id\/upgrade"
        },
        {
            "name": "Change service label",
            "method": "POST",
            "route": "\/service\/@id\/label"
        },
        {
            "name": "Service label",
            "method": "GET",
            "route": "\/service\/@id\/label"
        },
        {
            "name": "Cancel Service",
            "method": "POST",
            "route": "\/service\/@id\/cancel"
        }
    ]
}

HTTP Request

GET /service/@id/methods

Query Parameters

Parameter	Type	Description
id	`int`

Upgrade Options

List upgrade options


curl -X GET "https://my.bkns.net/api/service/@id/upgrade" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/upgrade');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/upgrade', headers=headers)
print(req.json())

{
    "resources": [
        {
            "id": 1557,
            "name": "Bandwidth",
            "type": "select",
            "items": [
                {
                    "id": "9953",
                    "name": "100 GB",
                    "price": 1,
                    "setup_price": 0,
                    "selected": true
                },
                {
                    "id": "10103",
                    "name": "500 GB",
                    "price": 5,
                    "setup_price": 0,
                    "selected": false
                },
                {
                    "id": "10104",
                    "name": "1 TB",
                    "price": 10,
                    "setup_price": 0,
                    "selected": false
                }
            ]
        }
    ],
    "package": []
}

HTTP Request

GET /service/@id/upgrade

Query Parameters

Parameter	Type	Description
id	`int`

Upgrade Request

Estimate or request upgrade

// Format of ''resources'' paremeter
{
    "resource_id" : "qty_value", // sliders & qty fields
    "resource_id" : "item_id", // dropdown & radio fields
    "resource_id" : {
        "item_id": "qty_value" // dropdown with qty field
    }
}

POST_DATA="{
    \"resources\": \"resourcesValue\",
    \"package\": \"packageValue\",
    \"cycle\": \"cycleValue\",
    \"send\": \"sendValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/upgrade" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "resources" => "resourcesValue",
        "package" => "packageValue",
        "cycle" => "cycleValue",
        "send" => "sendValue"
    ]
]
$resp = $client->post('service/@id/upgrade', $options);
echo $resp->getBody();

payload = {
    'resources': "resourcesValue",
    'package': "packageValue",
    'cycle': "cycleValue",
    'send': "sendValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/upgrade', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /service/@id/upgrade

Query Parameters

Parameter	Type	Description
id	`int`	Service id
resources	`array`	array with resource values
package	`int`	New package id, optonal when upgrading resources
cycle	`string`	New billing cycle, optonal when upgrading resources
send	`boolean`	Set to true when you want to send your upgrade request

Cancel Service

Request service cancellation

POST_DATA="{
    \"immediate\": \"immediateValue\",
    \"reason\": \"reasonValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/cancel" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "immediate" => "immediateValue",
        "reason" => "reasonValue"
    ]
]
$resp = $client->post('service/@id/cancel', $options);
echo $resp->getBody();

payload = {
    'immediate': "immediateValue",
    'reason': "reasonValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/cancel', json=payload, headers=headers)
print(req.json())

{
  "info": [
    "cancell_sent"
  ]
}

HTTP Request

POST /service/@id/cancel

Query Parameters

Parameter	Type	Description
id	`int`	Service id
immediate	`string`	set to `false` to terminate service at the end of billing date, `true` - terminate immediately
reason	`string`	Reason for this request

Service label

Show current service label


curl -X GET "https://my.bkns.net/api/service/@id/label" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/label');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/label', headers=headers)
print(req.json())

{
    "label": "example"
}

HTTP Request

GET /service/@id/label

Query Parameters

Parameter	Type	Description
id	`int`	Service id

Change service label

Set new custom label to identify this service

POST_DATA="{
    \"label\": \"labelValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/label" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "label" => "labelValue"
    ]
]
$resp = $client->post('service/@id/label', $options);
echo $resp->getBody();

payload = {
    'label': "labelValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/label', json=payload, headers=headers)
print(req.json())

{
    "success": true,
    "info": [
        "label_updated"
    ]
}

HTTP Request

POST /service/@id/label

Query Parameters

Parameter	Type	Description
id	`int`	Service id
label	`string`	New label

List services

List all services under your account


curl -X GET "https://my.bkns.net/api/service" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service', headers=headers)
print(req.json())

{
    "services": [
        {
            "id": "301",
            "domain": "examplename.com",
            "total": "9.99",
            "status": "Pending",
            "billingcycle": "Monthly",
            "next_due": "2017-12-30",
            "category": "Hosting",
            "category_url": "hosting",
            "name": "Starter Hosting"
        }
    ]
}

HTTP Request

GET /service

Service details

Return details for service @id


curl -X GET "https://my.bkns.net/api/service/@id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id', headers=headers)
print(req.json())

{
    "service": {
        "id": "301",
        "date_created": "2016-12-30",
        "domain": "examplename.com",
        "firstpayment": "9.99",
        "total": "9.99",
        "billingcycle": "Monthly",
        "next_due": "2017-12-30",
        "next_invoice": "2017-01-27",
        "status": "Active",
        "label": "",
        "username": "examplen",
        "password": "pdtzc",
        "name": "Starter Hosting"
    }
}

HTTP Request

GET /service/@id

Query Parameters

Parameter	Type	Description
id	`int`	Service id

List VMs

List virtual servers


curl -X GET "https://my.bkns.net/api/service/@id/vms" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/vms');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/vms', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/vms

Query Parameters

Parameter	Type	Description
id	`int`

Get VM Details

Get the details of a particular virtual server


curl -X GET "https://my.bkns.net/api/service/@id/vms/@vmid" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/vms/@vmid');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/vms/@vmid', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/vms/@vmid

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Stop VM

Stop virtual server


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/stop" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/stop');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/stop', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/stop

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Start VM

Start virtual servers


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/start" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/start');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/start', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/start

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Shutdown VM

Perform graceful shutdown


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/shutdown" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/shutdown');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/shutdown', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/shutdown

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Reboot VM

Reboot virtual servers


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/reboot" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/reboot');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/reboot', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/reboot

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Reset VM

Reset virtual servers power


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/reset" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/reset');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/reset', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/reset

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Rebuild VM

Rebuild server, you can get list of templates supported by this server using '''/service/$id/vms/$vmid/rebuild'''

POST_DATA="{
    \"template\": \"templateValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/rebuild" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "template" => "templateValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/rebuild', $options);
echo $resp->getBody();

payload = {
    'template': "templateValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/rebuild', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/rebuild

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
template	`string`	Template ID

List IPs

List virtual machine IPs


curl -X GET "https://my.bkns.net/api/service/@id/vms/@vmid/ips" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/vms/@vmid/ips');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/vms/@vmid/ips', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/vms/@vmid/ips

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
type		string ipv4 or ipv6
iface		int Interface number [optional]
bridge		string Bridge name [optional, ignored if interface provided]

List IPs

List virtual machine IPs


curl -X GET "https://my.bkns.net/api/service/@id/vms/@vmid/ippool" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/vms/@vmid/ippool');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/vms/@vmid/ippool', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/vms/@vmid/ippool

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
iface		int Interface number [optional]
bridge		string Bridge name [optional, ignored if interface provided]

Assign IPs

Assign new IP for network interface.

POST_DATA="{
    \"type\": \"typeValue\",
    \"iface\": \"ifaceValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/ippool/@pool" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "type" => "typeValue",
        "iface" => "ifaceValue"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/ippool/@pool', $options);
echo $resp->getBody();

payload = {
    'type': "typeValue",
    'iface': "ifaceValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/ippool/@pool', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/ippool/@pool

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
pool		string\|int List ID to allocate new IP from
type		string ipv4 or ipv6
iface		int Interface number

List available networks

List networks and IP pools that can be used for VM creation


curl -X GET "https://my.bkns.net/api/service/@id/networks" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/networks');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/networks', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/networks

Query Parameters

Parameter	Type	Description
id	`int`

List VM Network Interfaces

Get network Interfaces assigned to virtual servers


curl -X GET "https://my.bkns.net/api/service/@id/vms/@vmid/interfaces" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/vms/@vmid/interfaces');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/vms/@vmid/interfaces', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/vms/@vmid/interfaces

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`

Get Network Interfaces

Get network Interface details


curl -X GET "https://my.bkns.net/api/service/@id/vms/@vmid/interfaces/@iface" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/vms/@vmid/interfaces/@iface');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/vms/@vmid/interfaces/@iface', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/vms/@vmid/interfaces/@iface

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
iface		string Interface name or id, ie '0' or 'net0'

Update Network Interfaces

Update network interface details

POST_DATA="{
    \"firewall\": \"firewallValue\",
    \"ipv4\": \"ipv4Value\",
    \"ipv6\": \"ipv6Value\"
}"

curl -X PUT "https://my.bkns.net/api/service/@id/vms/@vmid/interfaces/@iface" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "firewall" => "firewallValue",
        "ipv4" => "ipv4Value",
        "ipv6" => "ipv6Value"
    ]
]
$resp = $client->put('service/@id/vms/@vmid/interfaces/@iface', $options);
echo $resp->getBody();

payload = {
    'firewall': "firewallValue",
    'ipv4': "ipv4Value",
    'ipv6': "ipv6Value"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/service/@id/vms/@vmid/interfaces/@iface', json=payload, headers=headers)
print(req.json())

HTTP Request

PUT /service/@id/vms/@vmid/interfaces/@iface

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
iface		int Interface number
firewall		int Enable or disable firewall (may require specific permissions)
ipv4		int[] List of IP v4 IDs
ipv6		int[] List of IP v6 IDs

Add Network Interface

Add new network interface to VM

POST_DATA="{
    \"firewall\": \"firewallValue\",
    \"ipv4\": \"ipv4Value\",
    \"ipv6\": \"ipv6Value\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/interfaces" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "firewall" => "firewallValue",
        "ipv4" => "ipv4Value",
        "ipv6" => "ipv6Value"
    ]
]
$resp = $client->post('service/@id/vms/@vmid/interfaces', $options);
echo $resp->getBody();

payload = {
    'firewall': "firewallValue",
    'ipv4': "ipv4Value",
    'ipv6': "ipv6Value"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/interfaces', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/interfaces

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
firewall		int Enable or disable firewall (may require specific permissions)
ipv4		int[] List of IP v4 IDs
ipv6		int[] List of IP v6 IDs

Remove Network Interface

Remove network interface from VM


curl -X DELETE "https://my.bkns.net/api/service/@id/vms/@vmid/interfaces/@iface" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->delete('service/@id/vms/@vmid/interfaces/@iface');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.delete('https://my.bkns.net/api/service/@id/vms/@vmid/interfaces/@iface', headers=headers)
print(req.json())

HTTP Request

DELETE /service/@id/vms/@vmid/interfaces/@iface

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`int`
iface	`string`
list		string\|int List to allocate new IP from

List OS templates

List templates that can be used to create virtual server


curl -X GET "https://my.bkns.net/api/service/@id/templates" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/templates');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/templates', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/templates

Query Parameters

Parameter	Type	Description
id	`int`

Resources

Show available and used resources


curl -X GET "https://my.bkns.net/api/service/@id/resources" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/resources');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/resources', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/resources

Query Parameters

Parameter	Type	Description
id	`int`

IP Addresses

List Service IP Addresses


curl -X GET "https://my.bkns.net/api/service/@id/ip" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/ip');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/ip', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/ip

Query Parameters

Parameter	Type	Description
id	`int`	Service ID

Reverse DNS

Get reverse DNS entries for service's IP addresses


curl -X GET "https://my.bkns.net/api/service/@id/rdns" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@id/rdns');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@id/rdns', headers=headers)
print(req.json())

HTTP Request

GET /service/@id/rdns

Query Parameters

Parameter	Type	Description
id	`int`	Service ID

Update rDNS

Update reverse DNS entries service's IP addresses

POST_DATA="{
    \"ipaddress\": \"ipaddressValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/rdns" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "ipaddress" => "ipaddressValue"
    ]
]
$resp = $client->post('service/@id/rdns', $options);
echo $resp->getBody();

payload = {
    'ipaddress': "ipaddressValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/rdns', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /service/@id/rdns

Query Parameters

Parameter	Type	Description
id	`int`	Service ID
ipaddress	`array`	Use Ip address as parameter key and hostname as value

Create VM

Add new virtual server

POST_DATA="{
    \"label\": \"labelValue\",
    \"template\": \"templateValue\",
    \"flavor\": \"flavorValue\",
    \"disk\": \"diskValue\",
    \"security_group\": \"security_groupValue\",
    \"keypair\": \"keypairValue\",
    \"password\": \"passwordValue\"
}"

curl -X POST "https://my.bkns.net/api/service/@id/vms" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "label" => "labelValue",
        "template" => "templateValue",
        "flavor" => "flavorValue",
        "disk" => "diskValue",
        "security_group" => "security_groupValue",
        "keypair" => "keypairValue",
        "password" => "passwordValue"
    ]
]
$resp = $client->post('service/@id/vms', $options);
echo $resp->getBody();

payload = {
    'label': "labelValue",
    'template': "templateValue",
    'flavor': "flavorValue",
    'disk': "diskValue",
    'security_group': "security_groupValue",
    'keypair': "keypairValue",
    'password': "passwordValue"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms', json=payload, headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms

Query Parameters

Parameter	Type	Description
id	`int`
label	`string`	VM label
template	`string`	Template ID
flavor	`string`	Flavor describing VM cpu and memory size
disk	`string`	Disk Space in GB
security_group	`string`	Network security group
keypair	`string`	SSH Key name
password	`string`	Password for root user

Rescue VM

Reboot virtual servers into rescue mode.


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/rescue" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/rescue');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/rescue', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/rescue

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Unrescue VM

Disable rescue mode for server.


curl -X POST "https://my.bkns.net/api/service/@id/vms/@vmid/unrescue" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->post('service/@id/vms/@vmid/unrescue');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@id/vms/@vmid/unrescue', headers=headers)
print(req.json())

HTTP Request

POST /service/@id/vms/@vmid/unrescue

Query Parameters

Parameter	Type	Description
id	`int`
vmid	`string`	Virtual server id

Cart

Most of API methods found here will require service @id, you can lookup your service ids with /service method

Order new service

Create and submit new order for selected product.

To get available cycle and configuration options lookup product details using GET /order/@product_id

POST_DATA="{
    \"domain\": \"example.com\",
    \"cycle\": \"m\",
    \"pay_method\": \"1\",
    \"custom\": {
        \"1618\": {
            \"10330\": 1
        }
    },
    \"promocode\": \"T346F\",
    \"aff_id\": 55
}"

curl -X POST "https://my.bkns.net/api/order/@product_id" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "domain" => "example.com",
        "cycle" => "m",
        "pay_method" => "1",
        "custom" => [
            1618 => [
                10330 => 1
            ]
        ],
        "promocode" => "T346F",
        "aff_id" => 55
    ]
]);

$resp = $client->post('order/@product_id', $options);
echo $resp->getBody();

payload = {
    'domain': "example.com",
    'cycle': "m",
    'pay_method': "1",
    'custom': {
        '1618': {
            '10330': 1
        }
    },
    'promocode': "T346F",
    'aff_id': 55
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/order/@product_id', json=payload, headers=headers)
print(req.json())

{
    "order_num": 873340995,
    "invoice_id": "308979",
    "total": "9.99",
    "items": {
        "id": "10",
        "type": "Hosting",
        "name": "test.com",
        "product_id": "3"
    }
}

HTTP Request

POST /order/@product_id

Query Parameters

Parameter	Type	Description
product_id	`int`	Product ID
domain	`string`	Domain name, ie. example.com, may be optional
cycle	`string`	Billing period symbol
pay_method	`int`	Payment method ID
custom	`array`	Additional options data available for sop products
promocode	`string`	Promotion code
aff_id	`int`	Affiliate ID

Order multiple services

Create and submit new order for multiple services

Each item in the items array needs to include order type and parameters used by one of the method listed below:
• POST /order/$product_id - use product for item type
• POST /domain/order - use domain for item type
• POST /certificate/order - use certificate for item type

POST_DATA="{
    \"pay_method\": 1,
    \"ignore_errors\": \"No error\",
    \"items\": [
        {
            \"type\": \"product\",
            \"product_id\": 1080,
            \"domain\": \"hosting.com\",
            \"cycle\": \"a\"
        },
        {
            \"type\": \"certificate\",
            \"product_id\": 840,
            \"csr\": \"-----BEGIN CERTIFICATE REQUEST----- (...)\",
            \"years\": 1,
            \"approver_email\": \"admin@hosting.com\"
        },
        {
            \"type\": \"domain\",
            \"tld_id\": 6,
            \"name\": \"hosting.com\",
            \"action\": \"register\",
            \"years\": 1
        },
        {
            \"type\": \"domain\",
            \"domain_id\": 1002,
            \"action\": \"renew\",
            \"years\": 1
        }
    ],
    \"aff_id\": 55
}"

curl -X POST "https://my.bkns.net/api/order" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "pay_method" => 1,
        "ignore_errors" => "No error",
        "items" => [
            [
                "type" => "product",
                "product_id" => 1080,
                "domain" => "hosting.com",
                "cycle" => "a"
            ],
            [
                "type" => "certificate",
                "product_id" => 840,
                "csr" => "-----BEGIN CERTIFICATE REQUEST----- (...)",
                "years" => 1,
                "approver_email" => "admin@hosting.com"
            ],
            [
                "type" => "domain",
                "tld_id" => 6,
                "name" => "hosting.com",
                "action" => "register",
                "years" => 1
            ],
            [
                "type" => "domain",
                "domain_id" => 1002,
                "action" => "renew",
                "years" => 1
            ]
        ],
        "aff_id" => 55
    ]
]
$resp = $client->post('order', $options);
echo $resp->getBody();

payload = {
    'pay_method': 1,
    'ignore_errors': "No error",
    'items': [
        {
            'type': "product",
            'product_id': 1080,
            'domain': "hosting.com",
            'cycle': "a"
        },
        {
            'type': "certificate",
            'product_id': 840,
            'csr': "-----BEGIN CERTIFICATE REQUEST----- (...)",
            'years': 1,
            'approver_email': "admin@hosting.com"
        },
        {
            'type': "domain",
            'tld_id': 6,
            'name': "hosting.com",
            'action': "register",
            'years': 1
        },
        {
            'type': "domain",
            'domain_id': 1002,
            'action': "renew",
            'years': 1
        }
    ],
    'aff_id': 55
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/order', json=payload, headers=headers)
print(req.json())

{
    "order_num_list": [
        179534732,
        179534732,
        179534732
    ],
    "invoice_id": "503425",
    "total": "94.40",
    "items": [
        {
            "type": "Hosting",
            "id": "1025",
            "name": "hosting.com",
            "product_id": "1080"
        },
        {
            "type": "Hosting",
            "id": "1026",
            "name": "hosting.com",
            "product_id": "840"
        },
        {
            "type": "Domain Register",
            "id": "354",
            "name": "hosting.com",
            "product_id": "6"
        }
    ]
}

HTTP Request

POST /order

Query Parameters

Parameter	Type	Description
pay_method	`int`	Payment method ID
ignore_errors	`bool`	Process order even if some of the items were rejected due to errors
items	`array`	list with order items
aff_id	`int`	Affiliate ID

Get order quote

Calculate order cost and recurring prices for selected items. Use the same parameters as for POST /order

POST_DATA="{
    \"pay_method\": \"pay_methodValue\",
    \"output\": \"short\",
    \"items\": [
        {
            \"type\": \"product\",
            \"product_id\": 1080,
            \"domain\": \"hosting.com\",
            \"cycle\": \"a\"
        },
        {
            \"type\": \"certificate\",
            \"product_id\": 840,
            \"csr\": \"-----BEGIN CERTIFICATE REQUEST----- (...)\",
            \"years\": 1,
            \"approver_email\": \"admin@hosting.com\"
        },
        {
            \"type\": \"domain\",
            \"tld_id\": 6,
            \"name\": \"hosting.com\",
            \"action\": \"register\",
            \"years\": 1
        },
        {
            \"type\": \"domain\",
            \"domain_id\": 1002,
            \"action\": \"renew\",
            \"years\": 1
        }
    ]
}"

curl -X POST "https://my.bkns.net/api/quote" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "pay_method" => "pay_methodValue",
        "output" => "short",
        "items" => [
            [
                "type" => "product",
                "product_id" => 1080,
                "domain" => "hosting.com",
                "cycle" => "a"
            ],
            [
                "type" => "certificate",
                "product_id" => 840,
                "csr" => "-----BEGIN CERTIFICATE REQUEST----- (...)",
                "years" => 1,
                "approver_email" => "admin@hosting.com"
            ],
            [
                "type" => "domain",
                "tld_id" => 6,
                "name" => "hosting.com",
                "action" => "register",
                "years" => 1
            ],
            [
                "type" => "domain",
                "domain_id" => 1002,
                "action" => "renew",
                "years" => 1
            ]
        ]
    ]
]
$resp = $client->post('quote', $options);
echo $resp->getBody();

payload = {
    'pay_method': "pay_methodValue",
    'output': "short",
    'items': [
        {
            'type': "product",
            'product_id': 1080,
            'domain': "hosting.com",
            'cycle': "a"
        },
        {
            'type': "certificate",
            'product_id': 840,
            'csr': "-----BEGIN CERTIFICATE REQUEST----- (...)",
            'years': 1,
            'approver_email': "admin@hosting.com"
        },
        {
            'type': "domain",
            'tld_id': 6,
            'name': "hosting.com",
            'action': "register",
            'years': 1
        },
        {
            'type': "domain",
            'domain_id': 1002,
            'action': "renew",
            'years': 1
        }
    ]
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/quote', json=payload, headers=headers)
print(req.json())

{
    "summary": {
        "subtotal": 72.2,
        "total": 88.81,
        "credit": 0,
        "discount": 0,
        "cost": 72.2,
        "recurring": [
            {
                "title": "Annually",
                "price": 81.18,
                "value": "a"
            },
            {
                "title": "Monthly",
                "price": 1.48,
                "value": "m"
            }
        ],
        "tax": [
            {
                "name": "VAT",
                "tax": 16.61,
                "value": 23
            }
        ]
    },
    "items": [
        {
            "product": {
                "id": 1080,
                "category_name": "SSL",
                "category_id": 69,
                "name": "GeoTrust QuickSSL Premium",
                "domain": "test.api",
                (...)
            },
            "domains": {
                (...)
            },
            "coupon": {},
            "index": 0,
            "valid": true,
            "info": [],
            "error": []
        },
        {
            "product": {
                "id": 840,
                "category_name": "Proxmox",
                "category_id": 19,
                "name": "VPS",
                "domain": "user.test.api",
                (...)
            },
            "domains": {
                (...)
            },
            "coupon": {},
            "index": 1,
            "valid": true,
            "info": [],
            "error": []
        },
        {
            "product": null,
            "domains": {
                "hosting.com": {
                    "id": 6,
                    "index": 0,
                    "category_id": "6",
                    "category_name": "Domains",
                    "name": "hosting.com",
                    "tld": ".com",
                    "period": 1,
                    "price": "12.00",
                    (...) 
                }
            },
            "coupon": {},
            "index": 2,
            "valid": true,
            "info": [],
            "error": []
        }
    ]
}

HTTP Request

POST /quote

Query Parameters

Parameter Type Description

pay_method

int

Payment method ID

output

string

Type of output, default is short. Possible options

short - Basic details about the item in cart
config- Basic details and form components
full - All details available in cart

items

array

list with order items

List product categories

Return a list of product categories.


curl -X GET "https://my.bkns.net/api/category" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('category');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/category', headers=headers)
print(req.json())

{
    "categories": [
        {
            "id": "10",
            "name": "Hosting",
            "description": "",
            "slug": "hosting"
        },
        {
            "id": "6",
            "name": "Domains",
            "description": "",
            "slug": "domains"
        },
        {
            "id": "16",
            "name": "Dedicated",
            "description": "",
            "slug": "dedicated"
        }
    ]
}

HTTP Request

GET /category

Get product configuration details

Return product details with form configuration, addons and subproducts if available.


curl -X GET "https://my.bkns.net/api/order/@product_id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('order/@product_id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/order/@product_id', headers=headers)
print(req.json())

{
    "product": {
        "id": "333",
        "category_name": "Hosting",
        "category_id": "49",
        "name": "Starter Hosting",
        "price": 9.99,
        "recurring": "m",
        "setup": 0,
        "config": {
            "product": [
                {
                    "type": "select",
                    "title": "pickcycle",
                    "id": "cycle",
                    "name": "cycle",
                    "items": [
                        {
                            "title": "m",
                            "value": "m",
                            "price": 9.99,
                            "setup": 0,
                            "selected": true
                        },
                        {
                            "title": "a",
                            "value": "a",
                            "price": 109.89,
                            "setup": 0,
                            "selected": false
                        },
                        {
                            "title": "b",
                            "value": "b",
                            "price": 199.8,
                            "setup": 0,
                            "selected": false
                        },
                        {
                            "title": "t",
                            "value": "t",
                            "price": 299.7,
                            "setup": 0,
                            "selected": false
                        }
                    ],
                    "value": "m",
                    "price": 9.99,
                    "setup": 0
                },
                {
                    "type": "input",
                    "title": "domain",
                    "id": "domain",
                    "name": "domain",
                    "value": null
                }
            ],
            "forms": [
                {
                    "type": "select",
                    "title": "Disk Size",
                    "id": "1618",
                    "firstItemId": 10330,
                    "description": "",
                    "name": "custom[1618]",
                    "required": false,
                    "multiple": false,
                    "config": {
                        "conditionals": []
                    },
                    "value": [],
                    "textvalue": [],
                    "price": 0,
                    "recurring_price": 0,
                    "setup": 0,
                    "prorata_date": null,
                    "items": [
                        {
                            "title": "512MB",
                            "value": 1,
                            "id": 10330,
                            "price": 0,
                            "setup": 0,
                            "selected": false
                        },
                        {
                            "title": "1GB",
                            "value": 1,
                            "id": 10331,
                            "price": 0,
                            "setup": 0,
                            "selected": false
                        },
                        {
                            "title": "2GB",
                            "value": 1,
                            "id": 10332,
                            "price": 0,
                            "setup": 0,
                            "selected": false
                        }
                    ]
                },
                (...)
            ],
            "addons": [
                {
                    "type": "subitem",
                    "title": "Cpanel2: Add Extra IP",
                    "id": "31",
                    "value": null,
                    "description": "Automatically adds IP address to account",
                    "config": [
                        {
                            "type": "checkbox",
                            "title": "add",
                            "name": "addon[31]",
                            "checked": false
                        },
                        {
                            "type": "select",
                            "title": "billingcycle",
                            "name": "addon_cycles[31]",
                            "items": [
                                {
                                    "title": "m",
                                    "value": "m",
                                    "price": 5,
                                    "setup": 0,
                                    "selected": true
                                },
                                {
                                    "title": "q",
                                    "value": "q",
                                    "price": 20,
                                    "setup": 0,
                                    "selected": false
                                },
                                {
                                    "title": "a",
                                    "value": "a",
                                    "price": 50,
                                    "setup": 0,
                                    "selected": false
                                }
                            ]
                        }
                    ],
                    "price": 0,
                    "recurring_price": 0,
                    "setup": 0,
                    "prorata_date": null
                },
                (...)
            ],
            "subproducts": []
        },
        "recurring_price": 9.99,
        "prorata_date": null
    }
}

HTTP Request

GET /order/@product_id

Query Parameters

Parameter	Type	Description
product_id	`int`	Product ID

DNS

List DNS

Returns a list of all DNS


curl -X GET "https://my.bkns.net/api/dns" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('dns');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/dns', headers=headers)
print(req.json())

{
    "service_ids": [
        "10",
        "20"
    ],
    "zones": [
        {
            "domain_id": "60",
            "name": "booble.com",
            "service_id": "10"
        },
        {
            "domain_id": "61",
            "name": "bgg12ooble.com",
            "service_id": "20"
        }
    ]
}

HTTP Request

GET /dns

Add DNS Zone

Creates a new DNS zone

POST_DATA="{
    \"name\": \"testzone.com\"
}"

curl -X POST "https://my.bkns.net/api/service/@service_id/dns" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "name" => "testzone.com"
    ]
]
$resp = $client->post('service/@service_id/dns', $options);
echo $resp->getBody();

payload = {
    'name': "testzone.com"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@service_id/dns', json=payload, headers=headers)
print(req.json())

{
    "info": [
        "Domain zone testzone.com was created successfully."
    ]
}

HTTP Request

POST /service/@service_id/dns

Query Parameters

Parameter	Type	Description
service_id	`int`	Service ID
name	`string`	Zone name

List DNS for service

Returns a list of DNS zones under the service


curl -X GET "https://my.bkns.net/api/service/@service_id/dns" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->get('service/@service_id/dns');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.get('https://my.bkns.net/api/service/@service_id/dns', headers=headers)
print(req.json())

{
    "error": [
        "invalid method"
    ]
}

HTTP Request

GET /service/@service_id/dns

Query Parameters

Parameter	Type	Description
service_id	`int`	Service ID

Remove DNS zone

Deletes the selected DNS zone


curl -X DELETE "https://my.bkns.net/api/service/@service_id/dns/@zone_id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->delete('service/@service_id/dns/@zone_id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.delete('https://my.bkns.net/api/service/@service_id/dns/@zone_id', headers=headers)
print(req.json())

{
   "info": [
     "Domain zone testzone.com was deleted successfully."
   ]
}

HTTP Request

DELETE /service/@service_id/dns/@zone_id

Query Parameters

Parameter	Type	Description
service_id	`int`	Service ID
zone_id	`int`	Zone ID

Add DNS Record

Creates a new record in the DNS zone

POST_DATA="{
    \"name\": \"example.com\",
    \"ttl\": 3600,
    \"priority\": 10,
    \"type\": \"A\",
    \"content\": \"192.168.1.2\"
}"

# OR ...

POST_DATA="{
    \"name\": \"_sip._tcp.example.com\",
    \"ttl\": 3600,
    \"priority\": 10,
    \"type\": \"SRV\",
    \"content\": [
        10,
        5060,
        \"vc01.example.com\"
    ]
}"

curl -X POST "https://my.bkns.net/api/service/@service_id/dns/@zone_id/records" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "name" => "example.com",
        "ttl" => 3600,
        "priority" => 10,
        "type" => "A",
        "content" => "192.168.1.2"
    ]
]);

// OR ...

$options = [
    'json' => [
        "name" => "_sip._tcp.example.com",
        "ttl" => 3600,
        "priority" => 10,
        "type" => "SRV",
        "content" => [
            10,
            5060,
            "vc01.example.com"
        ]
    ]
]);

$resp = $client->post('service/@service_id/dns/@zone_id/records', $options);
echo $resp->getBody();

payload = {
    'name': "example.com",
    'ttl': 3600,
    'priority': 10,
    'type': "A",
    'content': "192.168.1.2"
}

# OR ...

payload = {
    'name': "_sip._tcp.example.com",
    'ttl': 3600,
    'priority': 10,
    'type': "SRV",
    'content': [
        10,
        5060,
        "vc01.example.com"
    ]
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.post('https://my.bkns.net/api/service/@service_id/dns/@zone_id/records', json=payload, headers=headers)
print(req.json())

{
    "record": {
      "name": "_sip._tcp.example.com",
      "type": "SRV",
      "ttl": "3600",
      "priority": "10",
      "content": [
        10,
        5060,
        "vc01.example.com"
      ]
    },
    "info": [
        "dnsnewrecordadded",
        "SRV"
    ]
}

HTTP Request

POST /service/@service_id/dns/@zone_id/records

Query Parameters

Parameter	Type	Description
service_id	`int`	Service ID
zone_id	`int`	Zone ID
name	`string`	Record name
ttl	`int`	Record ttl
priority	`int`	Priority of the record
type	`string`	Record type
content	`string`	Contents of the record

Edit DNS Record

Edits the selected DNS zone record

POST_DATA="{
    \"name\": \"example.com\",
    \"ttl\": 3600,
    \"priority\": 10,
    \"type\": \"A\",
    \"content\": \"192.168.1.2\"
}"

curl -X PUT "https://my.bkns.net/api/service/@service_id/dns/@zone_id/records/@record_id" \
   -H "Authorization: Bearer $token" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);

$options = [
    'json' => [
        "name" => "example.com",
        "ttl" => 3600,
        "priority" => 10,
        "type" => "A",
        "content" => "192.168.1.2"
    ]
]
$resp = $client->put('service/@service_id/dns/@zone_id/records/@record_id', $options);
echo $resp->getBody();

payload = {
    'name': "example.com",
    'ttl': 3600,
    'priority': 10,
    'type': "A",
    'content': "192.168.1.2"
}

headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.put('https://my.bkns.net/api/service/@service_id/dns/@zone_id/records/@record_id', json=payload, headers=headers)
print(req.json())

{
    "record": {
        "id": "55",
        "type": "A",
        "ttl": "3600",
        "name": "test",
        "priority": 0,
        "content": "192.168.1.2"
    },
    "info": [
        "The record was updated successfully."
    ]
}

HTTP Request

PUT /service/@service_id/dns/@zone_id/records/@record_id

Query Parameters

Parameter	Type	Description
service_id	`int`	Service ID
zone_id	`int`	Zone ID
record_id	`int`	Record ID
name	`string`	Record name
ttl	`int`	Record ttl
priority	`int`	Priority of the record
type	`string`	Record type
content	`string`	Contents of the record

Remove DNS Record

Removes the selected DNS zone record


curl -X DELETE "https://my.bkns.net/api/service/@service_id/dns/@zone_id/records/@record_id" \
   -H "Authorization: Bearer $token"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
    'headers' => [
        'Authorization' => 'Bearer ' . $token
    ]
]);


$resp = $client->delete('service/@service_id/dns/@zone_id/records/@record_id');
echo $resp->getBody();


headers = {
    'Authorization': 'Bearer ' + token
}

req = requests.delete('https://my.bkns.net/api/service/@service_id/dns/@zone_id/records/@record_id', headers=headers)
print(req.json())

HTTP Request

DELETE /service/@service_id/dns/@zone_id/records/@record_id

Query Parameters

Parameter	Type	Description
service_id	`int`	Service ID
zone_id	`int`	Zone ID
record_id	`int`	Record ID

Location

Countries List

Return currencies details


curl -X GET "https://my.bkns.net/api/location/countries"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('location/countries');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/location/countries')
print(req.json())

HTTP Request

GET /location/countries

Get state


curl -X GET "https://my.bkns.net/api/location/@code/state"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('location/@code/state');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/location/@code/state')
print(req.json())

HTTP Request

GET /location/@code/state

Query Parameters

Parameter	Type	Description
code	`string`	Country Code

Get city


curl -X GET "https://my.bkns.net/api/location/state/@id/city"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('location/state/@id/city');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/location/state/@id/city')
print(req.json())

HTTP Request

GET /location/state/@id/city

Query Parameters

Parameter	Type	Description
id	`int`	State id

Get city by State Name


curl -X GET "https://my.bkns.net/api/GET /location/state/city/@name"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('GET /location/state/city/@name');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/GET /location/state/city/@name')
print(req.json())

HTTP Request

GET /location/state/city/@name

Query Parameters

Parameter	Type	Description
name	`string`	State name

Get ward


curl -X GET "https://my.bkns.net/api/location/city/@id/ward"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('location/city/@id/ward');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/location/city/@id/ward')
print(req.json())

HTTP Request

GET /location/city/@id/ward

Query Parameters

Parameter	Type	Description
id	`int`	City id

Get ward by City Name


curl -X GET "https://my.bkns.net/api/location/city/ward/@name"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('location/city/ward/@name');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/location/city/ward/@name')
print(req.json())

HTTP Request

GET /location/city/ward/@name

Query Parameters

Parameter	Type	Description
name	`string`	City name

Willexpired

Get state


curl -X GET "https://my.bkns.net/api/willexpired/@code/state"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);


$resp = $client->get('willexpired/@code/state');
echo $resp->getBody();



req = requests.get('https://my.bkns.net/api/willexpired/@code/state')
print(req.json())

HTTP Request

GET /willexpired/@code/state

Query Parameters

Parameter	Type	Description
code	`string`	Country Code

Bkns_coupons

Mã Giam giá theo Người dùng

POST_DATA="{
    \"clientdata_coupons\": \"idValue\",
    \"sap_coupons\": \"idValue\",
    \"id_products_coupons\": \"idValue\",
    \"type\": \"idValue\"
}"

curl -X POST "https://my.bkns.net/api/domain/coupons/bkns_coupons" \
   -H "Content-Type: application/json" \
   -d "${POST_DATA}"

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://my.bkns.net/api/',
]);

$options = [
    'json' => [
        "clientdata_coupons" => "idValue",
        "sap_coupons" => "idValue",
        "id_products_coupons" => "idValue",
        "type" => "idValue"
    ]
]
$resp = $client->post('domain/coupons/bkns_coupons', $options);
echo $resp->getBody();

payload = {
    'clientdata_coupons': "idValue",
    'sap_coupons': "idValue",
    'id_products_coupons': "idValue",
    'type': "idValue"
}


req = requests.post('https://my.bkns.net/api/domain/coupons/bkns_coupons', json=payload)
print(req.json())

HTTP Request

POST /domain/coupons/bkns_coupons

Query Parameters

Parameter	Type	Description
clientdata_coupons	`int`	client ID
sap_coupons	`string`	sp name
id_products_coupons	`string`	sp id
type	`string`	type giam gai

Introduction

Authentication

JSON Web Token Authentication

Basic Authentication

Clientarea

Login

HTTP Request

Query Parameters

Logout

HTTP Request

Refresh Token

HTTP Request

Query Parameters

Revoke Token

HTTP Request

Query Parameters

Sign up

HTTP Request

Query Parameters

User Details

HTTP Request

User Logs

HTTP Request

Get Affiliate summary

HTTP Request

Get Affiliate campaigns

HTTP Request

Get Affiliate commissions

HTTP Request

Get Affiliate payouts

HTTP Request

Get Affiliate vouchers

HTTP Request

Get Affiliate commission plans

HTTP Request

List contacts

HTTP Request

Add contact

HTTP Request

Query Parameters

Contact privileges

HTTP Request

Get contacts details

HTTP Request

Query Parameters

Edit contact

HTTP Request

Query Parameters

List all portal notifications

HTTP Request

Query Parameters

List new portal notifications

HTTP Request

Query Parameters

Acknowledge notification

HTTP Request

Query Parameters

Returns a list of all statuses with specific status

HTTP Request

Query Parameters

Returns details of status

HTTP Request

Query Parameters

OCR Recognition

HTTP Request

Query Parameters

Faceid verification

HTTP Request

Query Parameters

Faceid verification

HTTP Request

Query Parameters

Get business info

HTTP Request

Query Parameters

Get gethouseholds info

HTTP Request

Query Parameters

Get emailloginbkns info

HTTP Request