MENU navbar-image

Introduction

Welcome to the Aksara Data Digital Documentation! You can use our API to access Aksara Data Digital Documentation endpoints.

We have language bindings in Shell, PHP, Python! You can view code examples in the dark area to the right, and you can switch the programming language of the examples with the tabs in the top right.

Production Environtment

https://api6.irsfa.id

Sandbox Environtment

http://api2.sandbox.irsfa.id

Authentication

OAUTH 2.0

Irsfa APIs is using OAuth 2.0 as the authorization framework. To get the access token, you need to be authorized by client_id and client_secret. To learn more about the OAuth 2.0 authorization framework, you can read the RFC6749 Documentation.

Access Token

access_token is an opaque string token that identify the user of the API. This token is required each time an application call API. There are several way to obtain an access_token, which will be described bellow.

Obtaining Access Token

Access token can be obtained in many way, depend on the grant_type of the application. To access all the services in this sandbox, you will need the access token with grant_type = client_credentials.

Client Credentials Grant

client_credentials grant will provide application access to API without requiring any user credential. Any call requested using access_token obtained using this method are made on behalf of the application instead of the user.

This grant type is designed to be used by server to server call. In order to obtain access_token a request must be made with following specification

Example request:
curl --request POST \
    "https://api6.irsfa.id/oauth/token" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"grant_type\": \"client_credentials\",
    \"client_id\": \"your_client_id\",
    \"client_secret\": \"your_client_secret\",
    \"scope\": \"\'\'\"
}"
const url = new URL(
    "https://api6.irsfa.id/oauth/token"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
};

let body = {
    "grant_type": "client_credentials",
    "client_id": "your_client_id",
    "client_secret": "your_client_secret",
    "scope": "''"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/oauth/token',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'grant_type' => 'client_credentials',
            'client_id' => 'your_client_id',
            'client_secret' => 'your_client_secret',
            'scope' => '\'\'',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/oauth/token'
payload = {
    "grant_type": "client_credentials",
    "client_id": "your_client_id",
    "client_secret": "your_client_secret",
    "scope": "''"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "token_type": "Bearer",
    "expires_in": 31622400,
    "access_token": "your access_token"
}
 

Example response (404, invalid user):


{
    "error": "invalid_client",
    "message": "Client authentication failed"
}
 

Request   

POST oauth/token

Body Parameters

Body Parameter Type Mandatory Description
grant_type string yes

value = client_credentials.

client_id string yes

your client_id.

client_secret string yes

your client_secret.

scope string optional

null.

Response

Response Fields

Response Field Type Description
token_type string

default is Bearer

expires_in integer

access_token validity, in seconds

access_token string

your access_token

Contact

Create Contact

This endpoint create new registrant/contact in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/contact/create" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"company_name\": \"Your Company\",
    \"first_name\": \"Jhon\",
    \"last_name\": \"Doe\",
    \"gender\": \"M\",
    \"telephone_number\": \"+6282111111111\",
    \"street\": \"Your Street Address\",
    \"number\": 19,
    \"zip_code\": 41111,
    \"city\": \"Jakarata Selatan\",
    \"state\": \"DKI Jakarata\",
    \"country\": \"ID\",
    \"email\": \"yourvalidemail@example.com\",
    \"locale\": \"en_GB\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/contact/create"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "company_name": "Your Company",
    "first_name": "Jhon",
    "last_name": "Doe",
    "gender": "M",
    "telephone_number": "+6282111111111",
    "street": "Your Street Address",
    "number": 19,
    "zip_code": 41111,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "locale": "en_GB"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/contact/create',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'company_name' => 'Your Company',
            'first_name' => 'Jhon',
            'last_name' => 'Doe',
            'gender' => 'M',
            'telephone_number' => '+6282111111111',
            'street' => 'Your Street Address',
            'number' => 19,
            'zip_code' => 41111,
            'city' => 'Jakarata Selatan',
            'state' => 'DKI Jakarata',
            'country' => 'ID',
            'email' => 'yourvalidemail@example.com',
            'locale' => 'en_GB',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/contact/create'
payload = {
    "company_name": "Your Company",
    "first_name": "Jhon",
    "last_name": "Doe",
    "gender": "M",
    "telephone_number": "+6282111111111",
    "street": "Your Street Address",
    "number": 19,
    "zip_code": 41111,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "locale": "en_GB"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfull Create Contact!",
    "data": {
        "no_contact": "contact_id"
    }
}
 

Example response (422, unprocessable content):


{
    "code": 422,
    "message": "The given data was invalid.",
    "error": []
}
 

Request   

POST api/rest/v3/domain/contact/create

Body Parameters

Body Parameter Type Mandatory Description
company_name string yes

Name of your company or organization.

first_name string yes

First of your name e.g Jhon.

last_name string yes

Last of your name e.g Doe.

gender string yes

Your gender e.g M (for male), F (for female).

telephone_number string yes

Your valid telephone number e.g +6282111111111.

street string yes

Street your residence.

number integer yes

Number of your residence.

zip_code integer yes

Postal code of your residence.

city string yes

City of your residence.

state string yes

Provice/State of your residence

country string yes

Country ID of your residence e.g ID (for Indonesia).

email string yes

Your valid email.

locale string yes

Your language code e.g en_GB (for English).

Response

Response Fields

Response Field Type Description
code integer

Response code

message string

Success/error message

data string[]

(array) Only available in success response

error string[]

(array) Only available in failed response

Update Contact

This endpoint update registrant/contact in your account. Your Request must contain following information:

Example request:
curl --request PUT \
    "https://api6.irsfa.id/api/rest/v3/domain/contact/update" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"contact_id\": \"Your Contatc Id\",
    \"telephone_number\": \"+628111111111\",
    \"street\": \"Your Street Address\",
    \"number\": 19,
    \"zip_code\": 41111,
    \"city\": \"Jakarata Selatan\",
    \"state\": \"DKI Jakarata\",
    \"country\": \"ID\",
    \"email\": \"yourvalidemail@example.com\",
    \"locale\": \"en_GB\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/contact/update"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "contact_id": "Your Contatc Id",
    "telephone_number": "+628111111111",
    "street": "Your Street Address",
    "number": 19,
    "zip_code": 41111,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "locale": "en_GB"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api6.irsfa.id/api/rest/v3/domain/contact/update',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'contact_id' => 'Your Contatc Id',
            'telephone_number' => '+628111111111',
            'street' => 'Your Street Address',
            'number' => 19,
            'zip_code' => 41111,
            'city' => 'Jakarata Selatan',
            'state' => 'DKI Jakarata',
            'country' => 'ID',
            'email' => 'yourvalidemail@example.com',
            'locale' => 'en_GB',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/contact/update'
payload = {
    "contact_id": "Your Contatc Id",
    "telephone_number": "+628111111111",
    "street": "Your Street Address",
    "number": 19,
    "zip_code": 41111,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "locale": "en_GB"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "no_contact": "contact_id"
    }
}
 

Example response (422, unprocessable content):


{
    "code": 422,
    "message": "The given data was invalid.",
    "error": []
}
 

Request   

PUT api/rest/v3/domain/contact/update

Body Parameters

Body Parameter Type Mandatory Description
contact_id string yes

Your Contact id.

telephone_number string yes

Your valid telephone number e.g +6282111111111.

street string yes

Street your residence.

number integer yes

Number of your residence.

zip_code integer yes

Postal code of your residence.

city string yes

City of your residence.

state string yes

Provice/State of your residence

country string yes

Country ID of your residence e.g ID (for Indonesia).

email string yes

Your valid email.

locale string yes

Your language code e.g en_GB (for English).

Response

Response Fields

Response Field Type Description
code integer

Response code

message string

Success/error message

data string[]

(array) Only available in success response

error string[]

(array) Only available in failed response

Domain

Check Domain

This endpoint is used to get domain availability. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/availability" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/availability"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/availability',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/availability'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (404, not found):


{
    "code": 404,
    "message": "Data not found.",
    "error": []
}
 

Request   

POST api/rest/v3/domain/availability

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Domain name you want to check.

domain_extension string yes

Domain extension you want to check.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Domain Info

Get domain information in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/info" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/info"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/info',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/info'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
   "code": 200,
   "message": "Successfully proccess the request!",
   "data": {
       "domain": "yourdomain.id",
       "status_domain": "Active",
       ...
   }
}
 

Example response (404, not found):


{
    "code": 404,
    "message": "Domain not found in your account!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/info

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Domain name.

domain_extension string yes

Domain extension.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data string[]

(array) Only available in success response

error string[]

(array) Only available in failed response

Register Domain

This endpoint is used to create new domain in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/register" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\",
    \"period\": 1,
    \"nameserver\": [
        \"quis\"
    ],
    \"description\": \"Register Domain\",
    \"company_name\": \"Your Company\",
    \"initial\": \"J.D\",
    \"first_name\": \"Jhon\",
    \"last_name\": \"Doe\",
    \"gender\": \"M\",
    \"street\": \"Your Street Address\",
    \"number\": 19,
    \"city\": \"Jakarata Selatan\",
    \"state\": \"DKI Jakarata\",
    \"zip_code\": 41111,
    \"country\": \"ID\",
    \"email\": \"yourvalidemail@example.com\",
    \"telephone_number\": \"+6282111111111\",
    \"locale\": \"en_GB\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/register"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "period": 1,
    "nameserver": [
        "quis"
    ],
    "description": "Register Domain",
    "company_name": "Your Company",
    "initial": "J.D",
    "first_name": "Jhon",
    "last_name": "Doe",
    "gender": "M",
    "street": "Your Street Address",
    "number": 19,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "zip_code": 41111,
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "telephone_number": "+6282111111111",
    "locale": "en_GB"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/register',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
            'period' => 1,
            'nameserver' => [
                'quis',
            ],
            'description' => 'Register Domain',
            'company_name' => 'Your Company',
            'initial' => 'J.D',
            'first_name' => 'Jhon',
            'last_name' => 'Doe',
            'gender' => 'M',
            'street' => 'Your Street Address',
            'number' => 19,
            'city' => 'Jakarata Selatan',
            'state' => 'DKI Jakarata',
            'zip_code' => 41111,
            'country' => 'ID',
            'email' => 'yourvalidemail@example.com',
            'telephone_number' => '+6282111111111',
            'locale' => 'en_GB',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/register'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "period": 1,
    "nameserver": [
        "quis"
    ],
    "description": "Register Domain",
    "company_name": "Your Company",
    "initial": "J.D",
    "first_name": "Jhon",
    "last_name": "Doe",
    "gender": "M",
    "street": "Your Street Address",
    "number": 19,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "zip_code": 41111,
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "telephone_number": "+6282111111111",
    "locale": "en_GB"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "domain": "yourdomain.id",
        "invoice_no": "IN-Q111123456"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/register

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Domain name you want to register.

domain_extension string yes

Domain extension you want to register.

period integer yes

Domain registration period.

nameserver string[] yes

Registered nameservers e.g [ns1.registeredns.id,ns2.registeredns.id].

description string yes

Description of your request.

company_name string yes

Name of your company or organization.

initial string yes

First letter of a word of your full name e.g J.D.

first_name string yes

First of your name e.g Jhon.

last_name string yes

Last of your name e.g Doe.

gender string yes

Your gender e.g M (for male), F (for female).

street string yes

Street your residence.

number integer yes

Number of your residence.

city string yes

City of your residence.

state string yes

Provice/State of your residence

zip_code integer yes

Postal code of your residence.

country string yes

Country ID of your residence e.g ID (for Indonesia).

email string yes

Your valid email.

telephone_number string yes

Your valid telephone number e.g +6282111111111.

locale string yes

Your language code e.g en_GB (for English).

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data string[]

(array) Only available in success response

error string[]

(array) Only available in failed response

Renew Domain

Renew domain in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/renew" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\",
    \"period\": 1,
    \"description\": \"Register Domain\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/renew"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "period": 1,
    "description": "Register Domain"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/renew',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
            'period' => 1,
            'description' => 'Register Domain',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/renew'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "period": 1,
    "description": "Register Domain"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (422, unprocessable content):


{
    "code": 422,
    "message": "The given data was invalid.",
    "error": []
}
 

Request   

POST api/rest/v3/domain/renew

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Domain name.

domain_extension string yes

Domain extension.

period integer yes

Domain registration period.

description string yes

Description of your register.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Transfer Domain

Use this endpoint to transfer domain in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/transfer" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\",
    \"epp\": \"1234AA?bbb5c6d7:e\",
    \"nameserver\": [
        \"nulla\"
    ],
    \"description\": \"Transfer domain to x\",
    \"company_name\": \"Your Company\",
    \"first_name\": \"Jhon\",
    \"last_name\": \"Doe\",
    \"gender\": \"M\",
    \"street\": \"Your Street Address\",
    \"number\": 19,
    \"city\": \"Jakarata Selatan\",
    \"state\": \"DKI Jakarata\",
    \"zip_code\": 41111,
    \"country\": \"ID\",
    \"email\": \"yourvalidemail@example.com\",
    \"telephone_number\": \"+6282111111111\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/transfer"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "epp": "1234AA?bbb5c6d7:e",
    "nameserver": [
        "nulla"
    ],
    "description": "Transfer domain to x",
    "company_name": "Your Company",
    "first_name": "Jhon",
    "last_name": "Doe",
    "gender": "M",
    "street": "Your Street Address",
    "number": 19,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "zip_code": 41111,
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "telephone_number": "+6282111111111"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/transfer',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
            'epp' => '1234AA?bbb5c6d7:e',
            'nameserver' => [
                'nulla',
            ],
            'description' => 'Transfer domain to x',
            'company_name' => 'Your Company',
            'first_name' => 'Jhon',
            'last_name' => 'Doe',
            'gender' => 'M',
            'street' => 'Your Street Address',
            'number' => 19,
            'city' => 'Jakarata Selatan',
            'state' => 'DKI Jakarata',
            'zip_code' => 41111,
            'country' => 'ID',
            'email' => 'yourvalidemail@example.com',
            'telephone_number' => '+6282111111111',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/transfer'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "epp": "1234AA?bbb5c6d7:e",
    "nameserver": [
        "nulla"
    ],
    "description": "Transfer domain to x",
    "company_name": "Your Company",
    "first_name": "Jhon",
    "last_name": "Doe",
    "gender": "M",
    "street": "Your Street Address",
    "number": 19,
    "city": "Jakarata Selatan",
    "state": "DKI Jakarata",
    "zip_code": 41111,
    "country": "ID",
    "email": "yourvalidemail@example.com",
    "telephone_number": "+6282111111111"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/transfer

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Domain name you want to transfer.

domain_extension string yes

Domain extension of the domain.

epp string yes

Epp/auth code of your domain.

nameserver string[] yes

Registered nameservers e.g ['ns1.registeredns.id', 'ns2.registeredns.id'].

description string optional

Description of your request.

company_name string optional

Name of your company or organization.

first_name string optional

First of your name e.g Jhon.

last_name string optional

Last of your name e.g Doe.

gender string optional

Your gender e.g M (for male), F (for female).

street string optional

Street your residence.

number integer optional

Number of your residence.

city string optional

City of your residence.

state string optional

Provice/State of your residence

zip_code integer optional

Postal code of your residence.

country string optional

Country ID of your residence e.g ID (for Indonesia).

email string optional

Your valid email.

telephone_number string optional

Your valid telephone number e.g +6282111111111.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Restore Domain

This endpoint is used to restore domain in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/restore" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\",
    \"period\": 1,
    \"description\": \"Register Domain\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/restore"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "period": 1,
    "description": "Register Domain"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/restore',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
            'period' => 1,
            'description' => 'Register Domain',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/restore'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "period": 1,
    "description": "Register Domain"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/restore

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

period integer yes

Domain registration period.

description string yes

Description of your request.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Update Lock/Unlock Domain

This endpoint used to lock or unlock domain in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/lock" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\",
    \"status\": 0
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/lock"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "status": 0
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/lock',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
            'status' => 0,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/lock'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "status": 0
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": "Domain unlocked!"
}
 

Example response (422, unprocessable content):


{
    "code": 422,
    "message": "The given data was invalid.",
    "error": []
}
 

Request   

POST api/rest/v3/domain/lock

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

status integer yes

(1)Lock or (0)unlock domain.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data string

Only available in success response

error string[]

(array) Only available in failed response

Get Epp Code

This endpoint is used to get EPP code of your domain. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/eppcode" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/eppcode"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/eppcode',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/eppcode'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": "AAb1abAb"
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/eppcode

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data string

Only available in success response

error string[]

(array) Only available in failed response

Update Domain Host

Use this endpoint to update domain nameserver in your account. Your Request must contain following information:

Example request:
curl --request PUT \
    "https://api6.irsfa.id/api/rest/v3/domain/modify/ns" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"id\",
    \"nameserver\": [
        \"ut\"
    ]
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/modify/ns"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "nameserver": [
        "ut"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->put(
    'https://api6.irsfa.id/api/rest/v3/domain/modify/ns',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'id',
            'nameserver' => [
                'ut',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/modify/ns'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "id",
    "nameserver": [
        "ut"
    ]
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('PUT', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": "Successfully modfy nameserver."
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

PUT api/rest/v3/domain/modify/ns

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

nameserver string[] yes

The new nameserver e.g ['ns1.registeredns.id'].

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data string

Only available in success response

error string[]

(array) Only available in failed response

Upload Document Domain Terms

This endpoint upload domain document terms in your account. Your Request must contain following information:

List Of Document Id:
1 = KTP
2 = Driving License
3 = Pasport
4 = TDP (Company Registration Cetificate)
5 = VAT (Value Added Tax)
6 = Authorization & Declaration Letter

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/doc/term/upload" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \"com\",
    \"document_id\": \"1\",
    \"document_name\": \"my_ktp\",
    \"document_description\": \"my_ktp Upload\",
    \"file\": \"path\\/to\\/fileupload.jpg\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/doc/term/upload"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": "com",
    "document_id": "1",
    "document_name": "my_ktp",
    "document_description": "my_ktp Upload",
    "file": "path\/to\/fileupload.jpg"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/doc/term/upload',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => 'com',
            'document_id' => '1',
            'document_name' => 'my_ktp',
            'document_description' => 'my_ktp Upload',
            'file' => 'path/to/fileupload.jpg',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/doc/term/upload'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": "com",
    "document_id": "1",
    "document_name": "my_ktp",
    "document_description": "my_ktp Upload",
    "file": "path\/to\/fileupload.jpg"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
   "code": 200,
   "message": "Successfully proccess the request!",
   "data": [
      {
          "client_id": "client id",
          "domain": "yourdomain.com",
          "key_tag": "11111",
          "alg": "",
          "digest_type": "",
          "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12",
          "updated_at": "",
          "created_at": ""
      },
      ...
  ]
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/doc/term/upload

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

document_id string yes

Document Id e.g 1 (For KTP).

document_name string yes

Nameof your document.

document_description string yes

Description of your document.

file string yes

File your upload (real path file your upload).

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Host

Info Host/Nameserver

Use this endpoint to get host info in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/nameserver/get" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"host\": \"ns.mydomain.com\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/nameserver/get"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "host": "ns.mydomain.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/nameserver/get',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'host' => 'ns.mydomain.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/nameserver/get'
payload = {
    "host": "ns.mydomain.com"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/nameserver/get

Body Parameters

Body Parameter Type Mandatory Description
host string yes

host name.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Create Host/Nameserver

Use this endpoint to create nameserver in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/nameserver/create" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"host\": \"ns.mydomain.com\",
    \"ipv4\": \"123.23.23.23\",
    \"ipv6\": \"1234:0:0:0:5:600:700C:890A\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/nameserver/create"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "host": "ns.mydomain.com",
    "ipv4": "123.23.23.23",
    "ipv6": "1234:0:0:0:5:600:700C:890A"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/nameserver/create',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'host' => 'ns.mydomain.com',
            'ipv4' => '123.23.23.23',
            'ipv6' => '1234:0:0:0:5:600:700C:890A',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/nameserver/create'
payload = {
    "host": "ns.mydomain.com",
    "ipv4": "123.23.23.23",
    "ipv6": "1234:0:0:0:5:600:700C:890A"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/nameserver/create

Body Parameters

Body Parameter Type Mandatory Description
host string yes

host name.

ipv4 string yes

ipv4 address.

ipv6 string yes

ipv6 address.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Delete Host/Nameserver

Use this endpoint to delete nameserver in your account. Your Request must contain following information:

Example request:
curl --request DELETE \
    "https://api6.irsfa.id/api/rest/v3/domain/nameserver/delete" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"nameserver_id\": 1234,
    \"host\": \"ns.mydomain.com\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/nameserver/delete"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "nameserver_id": 1234,
    "host": "ns.mydomain.com"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api6.irsfa.id/api/rest/v3/domain/nameserver/delete',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'nameserver_id' => 1234,
            'host' => 'ns.mydomain.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/nameserver/delete'
payload = {
    "nameserver_id": 1234,
    "host": "ns.mydomain.com"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

DELETE api/rest/v3/domain/nameserver/delete

Body Parameters

Body Parameter Type Mandatory Description
nameserver_id integer yes

ID of nameserver.

host string yes

host name.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

DNSSEC

Get Detail

Use this endpoint to get DNSSEC. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/dnssec/get" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \".com\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/dnssec/get"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": ".com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/dnssec/get',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => '.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/dnssec/get'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": ".com"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
   "code": 200,
   "message": "Successfully proccess the request!",
   "data": [
      {
          "client_id": "client id",
          "domain": "yourdomain.com",
          "key_tag": "11111",
          "alg": "",
          "digest_type": "",
          "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12",
          "updated_at": "",
          "created_at": ""
      },
      ...
  ]
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/dnssec/get

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Create

Use this endpoint to create DNSSEC. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/domain/dnssec/create" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \".com\",
    \"key_tag\": \"54321\",
    \"alg\": 8,
    \"digest_type\": 1,
    \"digest\": \"123ABC123ABCBC12AB3CABC123AB12C3A123BC12\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/dnssec/create"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": ".com",
    "key_tag": "54321",
    "alg": 8,
    "digest_type": 1,
    "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/domain/dnssec/create',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => '.com',
            'key_tag' => '54321',
            'alg' => 8,
            'digest_type' => 1,
            'digest' => '123ABC123ABCBC12AB3CABC123AB12C3A123BC12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/dnssec/create'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": ".com",
    "key_tag": "54321",
    "alg": 8,
    "digest_type": 1,
    "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": true
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/domain/dnssec/create

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

key_tag string yes

-

alg integer yes

-

digest_type integer yes

-

digest string optional

-

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data boolean

Only available in success response

error string[]

(array) Only available in failed response

Delete

Use this endpoint to delete DNSSEC. Your Request must contain following information:

Example request:
curl --request DELETE \
    "https://api6.irsfa.id/api/rest/v3/domain/dnssec/delete" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain_name\": \"yourdomain\",
    \"domain_extension\": \".com\",
    \"key_tag\": \"54321\",
    \"alg\": 8,
    \"digest_type\": 1,
    \"digest\": \"123ABC123ABCBC12AB3CABC123AB12C3A123BC12\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/domain/dnssec/delete"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain_name": "yourdomain",
    "domain_extension": ".com",
    "key_tag": "54321",
    "alg": 8,
    "digest_type": 1,
    "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12"
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->delete(
    'https://api6.irsfa.id/api/rest/v3/domain/dnssec/delete',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain_name' => 'yourdomain',
            'domain_extension' => '.com',
            'key_tag' => '54321',
            'alg' => 8,
            'digest_type' => 1,
            'digest' => '123ABC123ABCBC12AB3CABC123AB12C3A123BC12',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/domain/dnssec/delete'
payload = {
    "domain_name": "yourdomain",
    "domain_extension": ".com",
    "key_tag": "54321",
    "alg": 8,
    "digest_type": 1,
    "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('DELETE', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "client_id": "client id",
        "domain": "yourdomain.com",
        "key_tag": "11111",
        "alg": "",
        "digest_type": "",
        "digest": "123ABC123ABCBC12AB3CABC123AB12C3A123BC12",
        "updated_at": "",
        "created_at": ""
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

DELETE api/rest/v3/domain/dnssec/delete

Body Parameters

Body Parameter Type Mandatory Description
domain_name string yes

Your domain name.

domain_extension string yes

Your domain extension.

key_tag string yes

-

alg integer yes

-

digest_type integer yes

-

digest string optional

-

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Hosting

Get Hosting Detail

This endpoint get detail hosting. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/hosting/detail" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"serviceID\": 1025
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/hosting/detail"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "serviceID": 1025
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/hosting/detail',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'serviceID' => 1025,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/hosting/detail'
payload = {
    "serviceID": 1025
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/hosting/detail

Body Parameters

Body Parameter Type Mandatory Description
serviceID integer yes

Your order serviceID. You can get serviceID from API create hosting.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Get Hosting Product

This endpoint get list product hosting. Your Request must contain following information:

Example request:
curl --request GET \
    --get "https://api6.irsfa.id/api/rest/v3/hosting/product" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/hosting/product"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api6.irsfa.id/api/rest/v3/hosting/product',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/hosting/product'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

GET api/rest/v3/hosting/product

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Create Hosting

This endpoint create new order hosting. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/hosting/create" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"domain\": \"example.com\",
    \"product_id\": \"PR0008\",
    \"username\": \"alexdoe\",
    \"email\": \"alexdoe@gmail.com\",
    \"password\": \"verys3cr3t\",
    \"period\": 1
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/hosting/create"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "domain": "example.com",
    "product_id": "PR0008",
    "username": "alexdoe",
    "email": "alexdoe@gmail.com",
    "password": "verys3cr3t",
    "period": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/hosting/create',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'domain' => 'example.com',
            'product_id' => 'PR0008',
            'username' => 'alexdoe',
            'email' => 'alexdoe@gmail.com',
            'password' => 'verys3cr3t',
            'period' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/hosting/create'
payload = {
    "domain": "example.com",
    "product_id": "PR0008",
    "username": "alexdoe",
    "email": "alexdoe@gmail.com",
    "password": "verys3cr3t",
    "period": 1
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/hosting/create

Body Parameters

Body Parameter Type Mandatory Description
domain string yes

Your domain name (yourdomainname.tld).

product_id string yes

Id product hosting.

username string yes

Your username is alphanumeric string.

email string yes

Your valid email.

password string yes

Your password. Password must be min 6 characters, contain at least 2 non alphanumeric characters, an uppercase character, and a number.

period integer yes

Hosting registration period. The period in Monthly e.g 1 (1 Month).

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Change Password Hosting

This endpoint change password hosting in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/hosting/change-password" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"serviceID\": 10245,
    \"password\": \"verys3cr3t\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/hosting/change-password"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "serviceID": 10245,
    "password": "verys3cr3t"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/hosting/change-password',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'serviceID' => 10245,
            'password' => 'verys3cr3t',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/hosting/change-password'
payload = {
    "serviceID": 10245,
    "password": "verys3cr3t"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/hosting/change-password

Body Parameters

Body Parameter Type Mandatory Description
serviceID integer yes

Your order serviceID. You can get serviceID from API create hosting.

password string yes

Your password. Password must be min 6 characters, contain at least 2 non alphanumeric characters, an uppercase character, and a number.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Suspend Hosting

This endpoint suspend hosting in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/hosting/suspend" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"serviceID\": 12457
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/hosting/suspend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "serviceID": 12457
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/hosting/suspend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'serviceID' => 12457,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/hosting/suspend'
payload = {
    "serviceID": 12457
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/hosting/suspend

Body Parameters

Body Parameter Type Mandatory Description
serviceID integer yes

Your order serviceID. You can get serviceID from API create hosting.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Unsuspend Hosting

This endpoint unsuspend hosting in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/hosting/unsuspend" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"serviceID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/hosting/unsuspend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "serviceID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/hosting/unsuspend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'serviceID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/hosting/unsuspend'
payload = {
    "serviceID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/hosting/unsuspend

Body Parameters

Body Parameter Type Mandatory Description
serviceID integer yes

Your order serviceID. You can get serviceID from API create hosting.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

SSL

Get Type SSL

This endpoint get type SSL. Your Request must contain following information:

Example request:
curl --request GET \
    --get "https://api6.irsfa.id/api/rest/v3/ssl/type" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/type"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api6.irsfa.id/api/rest/v3/ssl/type',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/type'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200, success):


{
"code": 200,
"message": "Successfully proccess the request!",
"data": [
    {
        "ssl_type_id": 1,
        "ssl_type_name": "Domain Validation",
        "active": 1,
        "created_time": 1557304040,
        "modify_time": 1557304040
    },
    {
        "ssl_type_id": 2,
        "ssl_type_name": "Extended Validation",
        "active": 1,
        "created_time": 1557304040,
        "modify_time": 1557304040
    },
]
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

GET api/rest/v3/ssl/type

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Get SSL Product

This endpoint get list product SSL. Your Request must contain following information:

Example request:
curl --request GET \
    --get "https://api6.irsfa.id/api/rest/v3/ssl/product" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/product"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api6.irsfa.id/api/rest/v3/ssl/product',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/product'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": [
        {
            "product_id": "PR00019",
            "product_type_name": "SSL",
            "product_name": "Sectigo Positive SSL - [Comodo]",
            "kurs_product": "IDR",
            "pricing_register": 65000,
            "pricing_renew": 65000,
            "pricing_transfer": null,
            "pricing_restore": 390000,
            "ssl_type_id": 1,
            "ssl_type_name": "Domain Validation",
            "registry_id": 2
        }
    ]
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

GET api/rest/v3/ssl/product

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Get SSL Detail

This endpoint get detail product SSL. Your Request must contain following information:

Example request:
curl --request GET \
    --get "https://api6.irsfa.id/api/rest/v3/ssl/detail" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": 1
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/detail"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "id": 1
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api6.irsfa.id/api/rest/v3/ssl/detail',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/detail'
payload = {
    "id": 1
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "id": 5,
        "product_id": "PR0001",
        "registry_id": 2,
        "status": 2,
        "product_name": "",
        "service_name": "example.com",
        "csr": "-----BEGIN CERTIFICATE[csr code here]-----END CERTIFICATE REQUEST-----",
        "organization_handle": "2023CCT0014292",
        "technical_handle": "2023CCT0014292",
        "admin_handle": null,
        "billing_handle": null,
        "approval_email": "admin@example.com",
        "email_reissue": null,
        "period": 1,
        "reg_date": "2023-06-20 09:07:11",
        "exp_date": "2024-06-20 09:07:11",
        "active_date": null,
        "certificate": null,
        "intermediate_certificate": null,
        "root_certificate": null,
        "validation_method": null,
        "domain_validation_methods": null,
        "domain_validation_statuses": null,
        "vendor_reference_id": null,
        "vendor_order_id": null,
        "additional_data": null,
        "sslinhva_order_id": null,
        "order_ends_at": null,
        "reissue_at": null,
        "created_at": "2023-06-20 09:07:10",
        "updated_at": "2023-06-30 14:23:54",
        "status_ssl": "Pending"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

GET api/rest/v3/ssl/detail

Body Parameters

Body Parameter Type Mandatory Description
id integer yes

orderID product ssl.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

List Order SSL

This endpoint get list order SSL product. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/list" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"hostname\": \"yourhost.com\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/list"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "hostname": "yourhost.com"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/list',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'hostname' => 'yourhost.com',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/list'
payload = {
    "hostname": "yourhost.com"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "current_page": 1,
        "data": [
            {
                "id": 32,
                "product_id": "PR0001",
                "registry_id": 2,
                "status": 1,
                "product_name": "Positive SSL - [Comodo]",
                "service_name": "www.example.com",
                "csr": "-----BEGIN CERTIFICATE REQUEST-----[csr code here]-----END CERTIFICATE REQUEST-----",
                "organization_handle": "BQ000268-ID",
                "technical_handle": "BQ000268-ID",
                "admin_handle": "BQ000268-ID",
                "billing_handle": "SR903538-NL",
                "approval_email": "admin@example.com",
                "email_reissue": "admin@example.com",
                "period": 1,
                "reg_date": "2023-06-28 14:31:29",
                "exp_date": "2023-07-14 14:31:29",
                "active_date": "2023-06-28 00:00:00",
                "certificate": "-----BEGIN CERTIFICATE-----[certificate here]-----END CERTIFICATE-----",
                "intermediate_certificate": "-----BEGIN CERTIFICATE-----[intermediate certificate here]-----END CERTIFICATE-----\r\n",
                "root_certificate": "-----BEGIN CERTIFICATE-----[root certificate here]-----END CERTIFICATE-----\r\n",
                "validation_method": "964464878",
                "domain_validation_methods": [
                    {
                        "hostName": "www.example.com",
                        "method": "admin@example.com"
                    },
                    {
                        "hostName": "www.example.com",
                        "method": "admin@example.com"
                    }
                ],
                "domain_validation_statuses": {
                    "status": "open",
                    "caOrderStatus": "issued",
                    "caStatus": "active",
                    "caOperation": "none"
                },
                "vendor_reference_id": "964464878",
                "vendor_order_id": "964464878",
                "additional_data": null,
                "sslinhva_order_id": "5cebf9be-d379-4ae6-bafd-433b3ca754c0",
                "order_ends_at": "2024-06-28 00:00:00",
                "reissue_at": null,
                "created_at": "2023-06-28 14:31:39",
                "updated_at": "2023-07-17 13:26:09",
                "status_ssl": "Active"
            }
        ],
        "first_page_url": "http:*api6.irsfa.id/api/rest/v3/ssl/list?page=1",
        "from": 1,
        "last_page": 1,
        "last_page_url": "http:*api6.irsfa.id/api/rest/v3/ssl/list?page=1",
        "links": [
            {
                "url": null,
                "label": "« Previous",
                "active": false
            },
            {
                "url": "http:*api6.irsfa.id/api/rest/v3/ssl/list?page=1",
                "label": "1",
                "active": true
            },
            {
                "url": null,
                "label": "Next »",
                "active": false
            }
        ],
        "next_page_url": null,
        "path": "http:*api6.irsfa.id/api/rest/v3/ssl/list",
        "per_page": 10,
        "prev_page_url": null,
        "to": 1,
        "total": 1
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/list

Body Parameters

Body Parameter Type Mandatory Description
hostname string yes

Your valid hostname.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Create Order SSL

This endpoint create new order SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/create" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"product_id\": \"PR00056\",
    \"hostname\": [
        \"optio\"
    ],
    \"csr\": \"hic\",
    \"contact\": \"iusto\",
    \"approval_email\": \"ad\",
    \"period\": \"vitae\",
    \"domain_validation_method\": [
        \"amet\"
    ]
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/create"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "product_id": "PR00056",
    "hostname": [
        "optio"
    ],
    "csr": "hic",
    "contact": "iusto",
    "approval_email": "ad",
    "period": "vitae",
    "domain_validation_method": [
        "amet"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/create',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'product_id' => 'PR00056',
            'hostname' => [
                'optio',
            ],
            'csr' => 'hic',
            'contact' => 'iusto',
            'approval_email' => 'ad',
            'period' => 'vitae',
            'domain_validation_method' => [
                'amet',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/create'
payload = {
    "product_id": "PR00056",
    "hostname": [
        "optio"
    ],
    "csr": "hic",
    "contact": "iusto",
    "approval_email": "ad",
    "period": "vitae",
    "domain_validation_method": [
        "amet"
    ]
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "registry_id": "2",
        "product_id": "41",
        "hostname": "www.example.com",
        "csr": "-----BEGIN CERTIFICATE REQUEST-----[csr code here]-----END CERTIFICATE REQUEST-----",
        "organization_handle": "TC000001-ID",
        "technical_handle": "TC000001-ID",
        "approval_email": "admin@example.com",
        "period": 1,
        "domain_validation_method": [
            {
                "hostName": "www.example.com",
                "method": "admin@example.com"
            }
        ]
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/create

Body Parameters

Body Parameter Type Mandatory Description
product_id string yes

Id product ssl.

hostname string[] yes

Your valid hostname.

csr string yes

Your valid CSR.

contact string yes

Contact account verified. Example : 2020CCT000123.

approval_email string yes

Contact email responsible. Example : admin@example.com.

period string yes

yearly period ssl. Example : 1.

domain_validation_method string[] yes

method for validation. Example : [{"hostname": "www.example.com", "method": "dns"}].

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Reissue SSL

This endpoint for reissue ordered SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/reissue" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": 4,
    \"hostname\": [
        \"nam\"
    ],
    \"csr\": \"in\",
    \"contact\": \"quam\",
    \"approval_email\": \"vel\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/reissue"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "id": 4,
    "hostname": [
        "nam"
    ],
    "csr": "in",
    "contact": "quam",
    "approval_email": "vel"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/reissue',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => 4,
            'hostname' => [
                'nam',
            ],
            'csr' => 'in',
            'contact' => 'quam',
            'approval_email' => 'vel',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/reissue'
payload = {
    "id": 4,
    "hostname": [
        "nam"
    ],
    "csr": "in",
    "contact": "quam",
    "approval_email": "vel"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "registry_id": 2,
        "id": 74,
        "hostname": "www.example.com",
        "csr": "-----BEGIN CERTIFICATE REQUEST-----[csr code here]-----END CERTIFICATE REQUEST-----",
        "organization_handle": "TC000002-ID",
        "technical_handle": "TC000002-ID",
        "approval_email": "admin@example.com"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/reissue

Body Parameters

Body Parameter Type Mandatory Description
id integer yes

OrderID product ssl.

hostname string[] yes

Your valid hostname.

csr string yes

Your valid CSR.

contact string yes

Contact account verified. Example : 2020CCT000123.

approval_email string yes

Contact email responsible. Example : admin@example.com.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Modify SSL

This endpoint for modify ordered SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/modify" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": 4,
    \"domain_validation_method\": [
        \"maxime\"
    ]
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/modify"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "id": 4,
    "domain_validation_method": [
        "maxime"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/modify',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => 4,
            'domain_validation_method' => [
                'maxime',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/modify'
payload = {
    "id": 4,
    "domain_validation_method": [
        "maxime"
    ]
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "id": "74"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/modify

Body Parameters

Body Parameter Type Mandatory Description
id integer yes

orderID product ssl.

domain_validation_method string[] yes

method for validation. Example : [{"hostname": "www.example.com", "method": "dns"}].

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Renew SSL

This endpoint for renew ordered SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/renew" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"id\": 4
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/renew"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "id": 4
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/renew',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'id' => 4,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/renew'
payload = {
    "id": 4
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "registry_id": 2,
        "id": 74
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/renew

Body Parameters

Body Parameter Type Mandatory Description
id integer yes

OrderID product ssl.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Generate CSR

This endpoint for generate CSR SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/generate" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"registry_id\": 2,
    \"bits\": 11,
    \"hostname\": \"yourhost.com\",
    \"country\": \"ID\",
    \"state\": \"Bandung\",
    \"locality\": \"ID\",
    \"organization\": \"voluptatum\",
    \"unit\": \"sapiente\",
    \"email\": \"autem\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/generate"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "registry_id": 2,
    "bits": 11,
    "hostname": "yourhost.com",
    "country": "ID",
    "state": "Bandung",
    "locality": "ID",
    "organization": "voluptatum",
    "unit": "sapiente",
    "email": "autem"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/generate',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'registry_id' => 2,
            'bits' => 11,
            'hostname' => 'yourhost.com',
            'country' => 'ID',
            'state' => 'Bandung',
            'locality' => 'ID',
            'organization' => 'voluptatum',
            'unit' => 'sapiente',
            'email' => 'autem',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/generate'
payload = {
    "registry_id": 2,
    "bits": 11,
    "hostname": "yourhost.com",
    "country": "ID",
    "state": "Bandung",
    "locality": "ID",
    "organization": "voluptatum",
    "unit": "sapiente",
    "email": "autem"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "command": "openssl req -new  -newkey rsa:2048 -nodes -out your.csr -keyout your.private.key -subj \"/C=ID/ST=Jakarta/L=ID/O=example/OU=1/CN=www.example.com/emailAddress=admin@example.com\"",
        "csr": "-----BEGIN CERTIFICATE REQUEST-----[csr code here]-----END CERTIFICATE REQUEST-----\n",
        "key": "-----BEGIN PRIVATE KEY-----[key code here]-----END PRIVATE KEY-----\n",
        "keyPath": "key_12345"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/generate

Body Parameters

Body Parameter Type Mandatory Description
registry_id integer yes

ssl registry id.

bits integer yes

bits of code CSR generate. Example : 2048

hostname string yes

Your valid hostname.

country string yes

Country of contact responsible.

state string yes

State of contact responsible.

locality string yes

Locality of contact responsible.

organization string yes

Organization of contact responsible

unit string yes

unit from organization of contact responsible

email string yes

Contact email responsible. Example : admin@example.com.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Decode CSR

This endpoint for decode CSR SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/decode" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"registry_id\": 2,
    \"csr\": \"aperiam\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/decode"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "registry_id": 2,
    "csr": "aperiam"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/decode',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'registry_id' => 2,
            'csr' => 'aperiam',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/decode'
payload = {
    "registry_id": 2,
    "csr": "aperiam"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "publicKey": {
            "bits": "2048",
            "key": "-----BEGIN PUBLIC KEY-----[key code here]-----END PUBLIC KEY-----\n"
        },
        "subject": {
            "commonName": "www.example.com",
            "organization": "example",
            "unit": "1",
            "locality": "ID",
            "state": "Jakarta",
            "country": "ID",
            "email": "admin@example.com"
        },
        "signatureHashAlgorithm": "sha256WithRSAEncryption",
        "subjectAlternativeName": null,
        "domainNamesCount": "1",
        "wildcardDomainNamesCount": null,
        "nonWildcardDomainNamesCount": "1"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/decode

Body Parameters

Body Parameter Type Mandatory Description
registry_id integer yes

registry_id of product ssl.

csr string yes

Your valid CSR.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Generate OTP

This endpoint for generate OTP SSL. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/ssl/generate/otp" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"registry_id\": 2,
    \"id\": 18
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/ssl/generate/otp"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "registry_id": 2,
    "id": 18
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/ssl/generate/otp',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'registry_id' => 2,
            'id' => 18,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/ssl/generate/otp'
payload = {
    "registry_id": 2,
    "id": 18
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {
        "uri": "http:*sslinhva.st001.openprovider.nl/auth-order-otp-token",
        "token": "exampletoken12345",
        "expireAt": "2023-07-26 08:33:48"
    }
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/ssl/generate/otp

Body Parameters

Body Parameter Type Mandatory Description
registry_id integer yes

registry_id of product ssl.

id integer yes

orderID of SSL product. Example : 4

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

VPS

Get VPS Product

This endpoint get list product vps. Your Request must contain following information:

Example request:
curl --request GET \
    --get "https://api6.irsfa.id/api/rest/v3/vps/product" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/product"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api6.irsfa.id/api/rest/v3/vps/product',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/product'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

GET api/rest/v3/vps/product

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Get Operating System (OS) VPS

This endpoint get list operating system (OS) VPS. Your Request must contain following information:

Example request:
curl --request GET \
    --get "https://api6.irsfa.id/api/rest/v3/vps/osvps" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/osvps"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->get(
    'https://api6.irsfa.id/api/rest/v3/vps/osvps',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/osvps'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('GET', url, headers=headers)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

GET api/rest/v3/vps/osvps

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Create VPS

This endpoint create new order vps. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/create" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"product_id\": \"PR00056\",
    \"rootpass\": \"verys3cr3t\",
    \"osid\": 2,
    \"hostname\": \"yourhost.com\",
    \"period\": 1
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/create"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "product_id": "PR00056",
    "rootpass": "verys3cr3t",
    "osid": 2,
    "hostname": "yourhost.com",
    "period": 1
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/create',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'product_id' => 'PR00056',
            'rootpass' => 'verys3cr3t',
            'osid' => 2,
            'hostname' => 'yourhost.com',
            'period' => 1,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/create'
payload = {
    "product_id": "PR00056",
    "rootpass": "verys3cr3t",
    "osid": 2,
    "hostname": "yourhost.com",
    "period": 1
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/create

Body Parameters

Body Parameter Type Mandatory Description
product_id string yes

Id product vps.

rootpass string yes

Your password root. Password must be min 6 characters, contain at least 2 non alphanumeric characters, an uppercase character, and a number.

osid integer yes

Select the operating system to use.

hostname string yes

Your valid hostname.

period integer yes

Hosting registration period. The period in Monthly e.g 1 (1 Month).

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Get VPS Detail

This endpoint get detail vps. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/detail" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/detail"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/detail',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/detail'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/detail

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Start VPS

This endpoint start vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/start" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/start"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/start',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/start'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/start

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Stop VPS

This endpoint stop vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/stop" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/stop"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/stop',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/stop'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/stop

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Restart VPS

This endpoint restart vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/restart" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/restart"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/restart',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/restart'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/restart

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Poweroff VPS

This endpoint poweroff vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/poweroff" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/poweroff"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/poweroff',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/poweroff'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/poweroff

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Suspend VPS

This endpoint suspend vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/suspend" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/suspend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/suspend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/suspend'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/suspend

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Unsuspend VPS

This endpoint unsuspend vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/unsuspend" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/unsuspend"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/unsuspend',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/unsuspend'
payload = {
    "vpsID": 123456
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/unsuspend

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response

Rebuild VPS

This endpoint rebuild vps in your account. Your Request must contain following information:

Example request:
curl --request POST \
    "https://api6.irsfa.id/api/rest/v3/vps/rebuild" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --header "Authorization: Bearer {access_token}" \
    --header "X-Requested-With: XMLHttpRequest" \
    --data "{
    \"vpsID\": 123456,
    \"osid\": 54,
    \"newpass\": \"verys3cr3t\",
    \"confirmation_new_pass\": \"verys3cr3t\"
}"
const url = new URL(
    "https://api6.irsfa.id/api/rest/v3/vps/rebuild"
);

const headers = {
    "Content-Type": "application/json",
    "Accept": "application/json",
    "Authorization": "Bearer {access_token}",
    "X-Requested-With": "XMLHttpRequest",
};

let body = {
    "vpsID": 123456,
    "osid": 54,
    "newpass": "verys3cr3t",
    "confirmation_new_pass": "verys3cr3t"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$response = $client->post(
    'https://api6.irsfa.id/api/rest/v3/vps/rebuild',
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
            'Authorization' => 'Bearer {access_token}',
            'X-Requested-With' => 'XMLHttpRequest',
        ],
        'json' => [
            'vpsID' => 123456,
            'osid' => 54,
            'newpass' => 'verys3cr3t',
            'confirmation_new_pass' => 'verys3cr3t',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://api6.irsfa.id/api/rest/v3/vps/rebuild'
payload = {
    "vpsID": 123456,
    "osid": 54,
    "newpass": "verys3cr3t",
    "confirmation_new_pass": "verys3cr3t"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'Authorization': 'Bearer {access_token}',
  'X-Requested-With': 'XMLHttpRequest'
}

response = requests.request('POST', url, headers=headers, json=payload)
response.json()

Example response (200, success):


{
    "code": 200,
    "message": "Successfully proccess the request!",
    "data": {}
}
 

Example response (500, failed):


{
    "code": 500,
    "message": "An error occurred!",
    "error": []
}
 

Request   

POST api/rest/v3/vps/rebuild

Body Parameters

Body Parameter Type Mandatory Description
vpsID integer yes

Your order vpsID. You can get vpsID from API create vps.

osid integer yes

Your osid VPS.

newpass string yes

Your new password. Password must be min 6 characters, contain at least 2 non alphanumeric characters, an uppercase character, and a number.

confirmation_new_pass string yes

Your new password. Password must be min 6 characters, contain at least 2 non alphanumeric characters, an uppercase character, and a number.

Response

Response Fields

Response Field Type Description
code integer

200

message string

Success/error message

data object

(object) Only available in success response

error string[]

(array) Only available in failed response