MENU navbar-image

Introduction

This documentation aims to provide all the information you need to work with our API.

Authenticating requests

To authenticate requests, include an Authorization header with the value "Bearer {YOUR_AUTH_KEY}".

All authenticated endpoints are marked with a requires authentication badge in the documentation below.

Impersonation: If you are an admin with the impersonate-users ability, you can impersonate another user by sending their ID in the X-Impersonate-User header.

Authorization Endpoints

Login

This endpoint allows a user to authenticate and receive an access token.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/login" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"[email protected]\",
    \"password\": \"secret123\",
    \"device_name\": \"iPhone 13\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/login"
);

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

let body = {
    "email": "[email protected]",
    "password": "secret123",
    "device_name": "iPhone 13"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/login';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
            'password' => 'secret123',
            'device_name' => 'iPhone 13',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/login'
payload = {
    "email": "[email protected]",
    "password": "secret123",
    "device_name": "iPhone 13"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/login

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

The user's email address. Must be a valid email address. Example: [email protected]

password   string   

The user's password. Example: secret123

device_name   string   

A name for the device making the request. Example: iPhone 13

Remind Password

Sends a password reset link to the provided email address, if it exists in the system.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/password/remind" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"[email protected]\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/password/remind"
);

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

let body = {
    "email": "[email protected]"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/password/remind';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/password/remind'
payload = {
    "email": "[email protected]"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/password/remind

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

The email address associated with the user's account. Must be a valid email address. Must not be greater than 255 characters. Example: [email protected]

Restore Password

Resets a user's password using a valid reset token.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/password/restore" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"token\": \"123456abcdef\",
    \"password\": \"NewSecureP@ss123\",
    \"password_confirmation\": \"NewSecureP@ss123\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/password/restore"
);

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

let body = {
    "token": "123456abcdef",
    "password": "NewSecureP@ss123",
    "password_confirmation": "NewSecureP@ss123"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/password/restore';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'token' => '123456abcdef',
            'password' => 'NewSecureP@ss123',
            'password_confirmation' => 'NewSecureP@ss123',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/password/restore'
payload = {
    "token": "123456abcdef",
    "password": "NewSecureP@ss123",
    "password_confirmation": "NewSecureP@ss123"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/password/restore

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

token   string   

The password reset token received by email. Example: 123456abcdef

password   string   

The new password (must be confirmed). Must be at least 5 characters. Example: NewSecureP@ss123

password_confirmation   string   

Must match the password field. Must be at least 5 characters. Example: NewSecureP@ss123

Activate User Account

Activates a user account based on the provided activation token.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/activate/9bdf52c2-2e13-4f9c-a53d-2b3f45ea9c20" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/activate/9bdf52c2-2e13-4f9c-a53d-2b3f45ea9c20"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/activate/9bdf52c2-2e13-4f9c-a53d-2b3f45ea9c20';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/activate/9bdf52c2-2e13-4f9c-a53d-2b3f45ea9c20'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (400):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Activation failed. Please contact support or try again.",
    "errors": null
}

Request   

GET api/v3/activate/{token}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

token   string   

The unique activation token sent by email. Example: 9bdf52c2-2e13-4f9c-a53d-2b3f45ea9c20

Logout

requires authentication

Revoke the current access token to log out the authenticated user.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/logout" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/logout"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/logout';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/logout'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/logout

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Client Endpoints

System

Get Translations

Returns all language translations for the specified locale.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/system/translations/en" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/system/translations/en"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/system/translations/en';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/system/translations/en'
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (200):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": true,
    "status": "success",
    "message": "success",
    "data": {
        "tab": {
            "summary": "Summary",
            "detailed_information": "Detailed Information",
            "graphs": "Graphs",
            "traffic_statistics": "Traffic Statistics",
            "power_usage": "Power Usage",
            "reverse_dns": "Reverse DNS",
            "ip_management": "IP Address Management"
        },
        "chart": {
            "inbound_total": "Traffic IN",
            "outbound_total": "Traffic OUT",
            "total_bound_bits": "Traffic IN & OUT",
            "95_percentile": "95th Percentile"
        },
        "stats": {
            "power_daily_usage": "Daily Usage",
            "power_weekly_usage": "Weekly Usage",
            "power_monthly_usage": "Monthly Usage",
            "power_previous_month_usage": "Previous Month"
        },
        "title": {
            "login": "Login",
            "register": "Register"
        },
        "user": {
            "myAccount": "My Account",
            "signOut": "Sign Out"
        },
        "general": {
            "all": "all",
            "unknown": "Unknown",
            "unassigned": "Unassigned",
            "not_found_or_unauthorized": "The requested entity does not exist or does not belong to you."
        },
        "auth": {
            "missing_bearer_token": "Missing bearer token.",
            "unauthorized_admin_access_only": "Unauthorized. Admin access only.",
            "invalid_email": "Your email is incorrect or this account does not exist.",
            "email_send_error": "Unable to send email. Please contact your administrator.",
            "email_send_success": "Success! Please check your mailbox.",
            "invalid_token": "Your token is incorrect or this account does not exist.",
            "validation_error": "Password reset failed due to validation errors.",
            "password_reset_success": "Your password has been updated successfully.",
            "activation_success": "Your account has been activated. You may now log in.",
            "activation_failed": "Activation failed. Please contact support or try again.",
            "user_not_found": "User not found.",
            "provided_credentials_are_incorrect": "The provided credentials are incorrect.",
            "your_account_is_inactive": "Your account is not active or has been banned.",
            "invalid_bearer_token": "Invalid bearer token.",
            "impersonated_user_not_found": "Impersonated user not found.",
            "impersonated_user_inactive": "Impersonated user account is inactive.",
            "only_admin_can_impersonate": "Only admin users are allowed to impersonate other users."
        },
        "service": {
            "not_found_or_unauthorized": "The requested service does not exist or does not belong to you.",
            "power_action_error": "An error occurred while attempting to perform the :action action on the server."
        },
        "2fa": {
            "already_enabled": "Two-factor authentication is already enabled.",
            "configuration_error": "There was an error while verifying the two-factor configuration.",
            "verification_failed": "Invalid code. Two-factor authentication failed.",
            "you_have_been_signed_in_using_backup_code_please_verify_your_two_factor_configuration": "You have signed in using a backup code. Please verify your two-factor configuration.",
            "please_provide_the_valid_password_for_your_account": "Please provide the valid password for your account.",
            "no_valid_backup_code_specified_into_configuration": "No valid backup code is stored in your configuration.",
            "invalid_or_empty_backup_code": "The backup code provided is invalid or has not been entered."
        },
        "actions": {
            "boot": "Boot",
            "reboot": "Reboot",
            "shutdown": "Shutdown",
            "boot_modal_title": "Boot Server",
            "boot_modal_desc": "Are you sure you want to boot this server?",
            "shutdown_modal_title": "Shutdown Server",
            "shutdown_modal_desc": "Are you sure you want to shut down this server?",
            "reboot_modal_title": "Reboot Server",
            "reboot_modal_desc": "Are you sure you want to reboot this server?",
            "cold_reset_modal_title": "Cold Reset BMC",
            "cold_reset_modal_desc": "This will force a cold reset of the BMC. Are you sure?",
            "rescue_mode_enable_title": "Enable Rescue Mode",
            "rescue_mode_enable_desc": "Do you really want to reboot the device in rescue mode?",
            "rescue_mode_enable_desc1": "If you confirm your request, your server will go into rescue mode and will reboot immediately. You will then receive an email containing the information required to log in to your server.",
            "rescue_mode_enable_desc2": "Downtime due to reboot: approximately 5 minutes.",
            "rescue_mode_disable_title": "Disable Rescue Mode",
            "rescue_mode_disable_desc": "This will boot the server into its normal OS. Proceed?",
            "osreinstall_modal_title": "Reinstall Operating System"
        }
    }
}

Request   

GET api/v3/client/system/translations/{locale}

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

locale   string   

The language code (e.g. "en", "pl"). Example: en

Show System Configuration

requires authentication

Returns basic system configuration.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/system-settings" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/system-settings"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/system-settings';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/system-settings'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/system-settings

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Users

Get Authenticated User

requires authentication

Returns the currently authenticated user's details.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/user" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/user"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/user

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Update User

requires authentication

Updates the currently authenticated user's details with the provided data.

Example request:
curl --request PUT \
    "https://your-easydcim.com/api/v3/client/user/edit" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"email\": \"[email protected]\",
    \"firstname\": \"John\",
    \"lastname\": \"Doe\",
    \"company\": \"Acme Inc.\",
    \"locale\": \"en\",
    \"timezone\": 133
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/edit"
);

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

let body = {
    "email": "[email protected]",
    "firstname": "John",
    "lastname": "Doe",
    "company": "Acme Inc.",
    "locale": "en",
    "timezone": 133
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/edit';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'email' => '[email protected]',
            'firstname' => 'John',
            'lastname' => 'Doe',
            'company' => 'Acme Inc.',
            'locale' => 'en',
            'timezone' => 133,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/edit'
payload = {
    "email": "[email protected]",
    "firstname": "John",
    "lastname": "Doe",
    "company": "Acme Inc.",
    "locale": "en",
    "timezone": 133
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

PUT api/v3/client/user/edit

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

email   string   

The user's email address. Must be unique. Must be a valid email address. Must not be greater than 255 characters. Example: [email protected]

firstname   string  optional  

The user's first name. Max 255 characters. Must not be greater than 255 characters. Example: John

lastname   string  optional  

The user's last name. Max 255 characters. Must not be greater than 255 characters. Example: Doe

company   string  optional  

The user's company name. Optional. Max 255 characters. Must not be greater than 255 characters. Example: Acme Inc.

locale   string  optional  

The language preference (e.g., ISO code). Example: en

timezone   integer  optional  

The ID of the selected timezone. See the Show System Configuration endpoint for valid values. Example: 133

Update User Password

requires authentication

Allows the authenticated user to change their password by providing the current password and a new one.

Example request:
curl --request PUT \
    "https://your-easydcim.com/api/v3/client/user/edit-password" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"current_password\": \"OldP@ssword123\",
    \"password\": \"NewSecureP@ss123\",
    \"password_confirmation\": \"NewSecureP@ss123\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/edit-password"
);

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

let body = {
    "current_password": "OldP@ssword123",
    "password": "NewSecureP@ss123",
    "password_confirmation": "NewSecureP@ss123"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/edit-password';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'current_password' => 'OldP@ssword123',
            'password' => 'NewSecureP@ss123',
            'password_confirmation' => 'NewSecureP@ss123',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/edit-password'
payload = {
    "current_password": "OldP@ssword123",
    "password": "NewSecureP@ss123",
    "password_confirmation": "NewSecureP@ss123"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

PUT api/v3/client/user/edit-password

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

current_password   string   

The user's current password. Example: OldP@ssword123

password   string   

The new password (must be confirmed). Must be at least 5 characters. Example: NewSecureP@ss123

password_confirmation   string   

Must match the password field. Must be at least 5 characters. Example: NewSecureP@ss123

SSH Keys

List SSH Keys

requires authentication

Returns a paginated list of SSH keys for the authenticated user.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/user/ssh-keys?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/ssh-keys"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/user/ssh-keys

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Create SSH Key

requires authentication

Creates a new SSH key associated with the authenticated client.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/user/ssh-keys" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Public Key\",
    \"ssh_key\": \"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...\",
    \"default\": false
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/ssh-keys"
);

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

let body = {
    "name": "Public Key",
    "ssh_key": "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...",
    "default": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Public Key',
            'ssh_key' => 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...',
            'default' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys'
payload = {
    "name": "Public Key",
    "ssh_key": "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...",
    "default": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/user/ssh-keys

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

The name of the SSH key. Example: Public Key

ssh_key   string   

The public SSH key content. Example: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...

default   boolean  optional  

Whether the key should be set as default. Example: false

Update SSH Key

requires authentication

Updates a given SSH key for the authenticated user.

Example request:
curl --request PUT \
    "https://your-easydcim.com/api/v3/client/user/ssh-keys/3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Public Key\",
    \"ssh_key\": \"ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...\",
    \"default\": false
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/ssh-keys/3"
);

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

let body = {
    "name": "Public Key",
    "ssh_key": "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...",
    "default": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys/3';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Public Key',
            'ssh_key' => 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...',
            'default' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys/3'
payload = {
    "name": "Public Key",
    "ssh_key": "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...",
    "default": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

PUT api/v3/client/user/ssh-keys/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the SSH key to update. Example: 3

Body Parameters

name   string   

The name of the SSH key. Example: Public Key

ssh_key   string   

The public SSH key content. Example: ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQCy...

default   boolean  optional  

Whether the key should be set as default. Example: false

Set SSH Key as Default

requires authentication

Sets a given SSH key as the default key for the authenticated client.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/user/ssh-keys/7/set-as-default" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/ssh-keys/7/set-as-default"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys/7/set-as-default';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys/7/set-as-default'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/user/ssh-keys/{id}/set-as-default

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the SSH key to mark as default. Example: 7

Delete SSH Key

requires authentication

Deletes a specific SSH key belonging to the authenticated client.

Example request:
curl --request DELETE \
    "https://your-easydcim.com/api/v3/client/user/ssh-keys/4" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/user/ssh-keys/4"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys/4';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/user/ssh-keys/4'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

DELETE api/v3/client/user/ssh-keys/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the ssh key. Example: 4

Services

List Services

requires authentication

Returns a paginated list of services for the authenticated client.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Show Service

requires authentication

Returns detailed information about a specific service.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Get Service Bandwidth

requires authentication

Retrieves bandwidth usage for a specific service. If a date range is provided, it returns detailed traffic data for that period. Otherwise, it returns historical usage data.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/101/bandwidth" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"startDate\": \"2024-01-01 00:00:00\",
    \"endDate\": \"2024-01-31 23:59:59\",
    \"units\": \"GB\",
    \"ports\": [
        12,
        100
    ]
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/101/bandwidth"
);

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

let body = {
    "startDate": "2024-01-01 00:00:00",
    "endDate": "2024-01-31 23:59:59",
    "units": "GB",
    "ports": [
        12,
        100
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/101/bandwidth';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'startDate' => '2024-01-01 00:00:00',
            'endDate' => '2024-01-31 23:59:59',
            'units' => 'GB',
            'ports' => [
                12,
                100,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/101/bandwidth'
payload = {
    "startDate": "2024-01-01 00:00:00",
    "endDate": "2024-01-31 23:59:59",
    "units": "GB",
    "ports": [
        12,
        100
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/bandwidth

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 101

Body Parameters

startDate   string  optional  

The start date for the traffic range. Must be a valid date. Must be a valid date. Example: 2024-01-01 00:00:00

endDate   string  optional  

The end date for the traffic range. Must be a valid date. Must be a valid date. Example: 2024-01-31 23:59:59

units   string  optional  

The unit of bandwidth. Must be one of: MB, GB, TB. Example: GB

Must be one of:
  • MB
  • GB
  • TB
ports   object  optional  

An array of device port names to include in the traffic query.

Get Service Power Usage

requires authentication

Retrieves power usage data for a specific service. If a date range is provided, it returns detailed power data for that period. Otherwise, it returns historical usage data.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/101/powerusage" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"startDate\": \"2024-01-01 00:00:00\",
    \"endDate\": \"2024-01-31 23:59:59\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/101/powerusage"
);

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

let body = {
    "startDate": "2024-01-01 00:00:00",
    "endDate": "2024-01-31 23:59:59"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/101/powerusage';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'startDate' => '2024-01-01 00:00:00',
            'endDate' => '2024-01-31 23:59:59',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/101/powerusage'
payload = {
    "startDate": "2024-01-01 00:00:00",
    "endDate": "2024-01-31 23:59:59"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/powerusage

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 101

Body Parameters

startDate   string  optional  

The start date for the traffic range. Must be a valid date. Must be a valid date. Example: 2024-01-01 00:00:00

endDate   string  optional  

The end date for the traffic range. Must be a valid date. Must be a valid date. Example: 2024-01-31 23:59:59

Perform Power Action

requires authentication

Executes a power-related action on a device assigned to the given service. This includes booting, rebooting, or shutting down the device.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/power/action" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"action\": \"boot\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/power/action"
);

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

let body = {
    "action": "boot"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/power/action';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'action' => 'boot',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/power/action'
payload = {
    "action": "boot"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/power/action

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Body Parameters

action   string   

The power action to perform. One of: boot, reboot, shutdown. Example: boot

Must be one of:
  • boot
  • reboot
  • shutdown

Parts

List Service Parts

requires authentication

Returns a paginated list of parts related to a specific service.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/parts?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/parts"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/parts';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/parts'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/parts

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Graphs

Export Graph

requires authentication

Exports a graph data for a given target

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/graphs/42/export" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"type\": \"AggregateTraffic\",
    \"target\": \"service\",
    \"start\": \"2025-04-01 00:00:00\",
    \"end\": \"2025-04-30 23:59:59\",
    \"raw\": false
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/graphs/42/export"
);

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

let body = {
    "type": "AggregateTraffic",
    "target": "service",
    "start": "2025-04-01 00:00:00",
    "end": "2025-04-30 23:59:59",
    "raw": false
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/graphs/42/export';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'type' => 'AggregateTraffic',
            'target' => 'service',
            'start' => '2025-04-01 00:00:00',
            'end' => '2025-04-30 23:59:59',
            'raw' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/graphs/42/export'
payload = {
    "type": "AggregateTraffic",
    "target": "service",
    "start": "2025-04-01 00:00:00",
    "end": "2025-04-30 23:59:59",
    "raw": false
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/graphs/{id}/export

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the target. Example: 42

Body Parameters

type   string   

The type of graph to export, depending on the target. Example: AggregateTraffic

Must be one of:
  • AggregateTraffic
  • Load
  • OutletPowerUsage
  • Ping
  • PowerUsage
  • Sensor
  • ServerPowerUsage
  • Status
target   string   

The type of target to graph (e.g., service, itempowerport, itemsensor). Example: service

Must be one of:
  • service
  • itempowerport
  • itemsensor
start   string  optional  

Start datetime for the graph range in format Y-m-d H:i:s. Must be a valid date in the format Y-m-d H:i:s. Example: 2025-04-01 00:00:00

end   string  optional  

End datetime for the graph range in format Y-m-d H:i:s. Must be after or equal to start. Must be a valid date in the format Y-m-d H:i:s. Must be a date after or equal to start. Example: 2025-04-30 23:59:59

raw   boolean  optional  

Whether to return raw graph data. Example: false

OS Installation

List ISO Images

requires authentication

Returns a paginated list of ISO images available to the authenticated client.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/os/isoimages?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/os/isoimages"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/os/isoimages';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/os/isoimages'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/os/isoimages

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Create ISO Image

requires authentication

Creates a new ISO image for the authenticated client.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/os/isoimages" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Ubuntu Server ISO\",
    \"iso_url\": \"https:\\/\\/example.com\\/images\\/ubuntu.iso\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/os/isoimages"
);

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

let body = {
    "name": "Ubuntu Server ISO",
    "iso_url": "https:\/\/example.com\/images\/ubuntu.iso"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/os/isoimages';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Ubuntu Server ISO',
            'iso_url' => 'https://example.com/images/ubuntu.iso',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/os/isoimages'
payload = {
    "name": "Ubuntu Server ISO",
    "iso_url": "https:\/\/example.com\/images\/ubuntu.iso"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/os/isoimages

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

name   string   

The display name for the ISO image. Must not be greater than 255 characters. Example: Ubuntu Server ISO

iso_url   string   

Direct URL to the ISO file. Must be publicly accessible and point to a valid .iso resource. Must be a valid URL. Example: https://example.com/images/ubuntu.iso

Update ISO Image

requires authentication

Updates the name of an existing ISO image for the authenticated client.

Example request:
curl --request PUT \
    "https://your-easydcim.com/api/v3/client/os/isoimages/3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"name\": \"Updated ISO Name\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/os/isoimages/3"
);

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

let body = {
    "name": "Updated ISO Name"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/os/isoimages/3';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'name' => 'Updated ISO Name',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/os/isoimages/3'
payload = {
    "name": "Updated ISO Name"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

PUT api/v3/client/os/isoimages/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the ISO image to update. Example: 3

Body Parameters

name   string   

The new name for the ISO image. Must not be greater than 255 characters. Example: Updated ISO Name

Delete ISO Image

requires authentication

Deletes a specific ISO image belonging to the authenticated client.

Example request:
curl --request DELETE \
    "https://your-easydcim.com/api/v3/client/os/isoimages/3" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/os/isoimages/3"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/os/isoimages/3';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/os/isoimages/3'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

DELETE api/v3/client/os/isoimages/{id}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the ISO image to delete. Example: 3

List OS Templates

requires authentication

Returns a paginated list of OS templates available for the given service.

Optionally, you can include a list of addons (based on template tags) by using the with_addons query parameter.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/os/templates?with_addons=1&per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/templates"
);

const params = {
    "with_addons": "1",
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/templates';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'with_addons' => '1',
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/templates'
params = {
  'with_addons': '1',
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/os/templates

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Query Parameters

with_addons   boolean  optional  

Optional. If set to true, includes a list of addons for each template. Example: true

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

List OS Addons

requires authentication

Returns a paginated list of OS addons available for the given service.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/os/addons?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/addons"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/addons';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/addons'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/os/addons

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Install OS on Device

requires authentication

Initiates OS installation on a device assigned to the given service

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/os/install" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"template\": 12,
    \"hostname\": \"server01.example.com\",
    \"username\": \"admin\",
    \"password\": \"secret123\",
    \"root_password\": \"rootsecret\",
    \"disk_addon\": 1,
    \"extras\": [
        14
    ],
    \"ssh_keys\": [
        14
    ]
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/install"
);

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

let body = {
    "template": 12,
    "hostname": "server01.example.com",
    "username": "admin",
    "password": "secret123",
    "root_password": "rootsecret",
    "disk_addon": 1,
    "extras": [
        14
    ],
    "ssh_keys": [
        14
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/install';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'template' => 12,
            'hostname' => 'server01.example.com',
            'username' => 'admin',
            'password' => 'secret123',
            'root_password' => 'rootsecret',
            'disk_addon' => 1,
            'extras' => [
                14,
            ],
            'ssh_keys' => [
                14,
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/install'
payload = {
    "template": 12,
    "hostname": "server01.example.com",
    "username": "admin",
    "password": "secret123",
    "root_password": "rootsecret",
    "disk_addon": 1,
    "extras": [
        14
    ],
    "ssh_keys": [
        14
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/os/install

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Body Parameters

template   integer   

ID or identifier of the OS template to install. Example: 12

hostname   string  optional  

Optional hostname for the new system. Example: server01.example.com

username   string   

Username for the new system. Example: admin

password   string   

Password for the user account. Example: secret123

root_password   string  optional  

Root password for the system (optional). Example: rootsecret

disk_addon   integer  optional  

Optional ID of an additional disk to use during installation. Example: 1

extras   integer[]  optional  
ssh_keys   integer[]  optional  

Cancel OS Installation

requires authentication

Attempts to cancel the operating system installation process

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/os/cancel" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/cancel"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/cancel';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/cancel'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/os/cancel

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

OS Installation Information

requires authentication

Returns details about the current OS installation process

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/os/install/information" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/install/information"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/install/information';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/install/information'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/os/install/information

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Enable Rescue Mode

requires authentication

Initiates rescue mode for the device assigned to the given service

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/os/rescue/enable" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/rescue/enable"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/rescue/enable';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/rescue/enable'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/os/rescue/enable

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Rescue Mode Status

requires authentication

Returns the current rescue mode status

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/os/rescue/status" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/os/rescue/status"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/os/rescue/status';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/os/rescue/status'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/os/rescue/status

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

IPMI

BMC Cold Reset

requires authentication

Sends a cold reset command to the BMC (Baseboard Management Controller) of the device associated with the given service. This action forces a full reboot of the BMC, which may temporarily interrupt device management features.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/ipmi/bmc-reset-cold" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/ipmi/bmc-reset-cold"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/ipmi/bmc-reset-cold';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/ipmi/bmc-reset-cold'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/ipmi/bmc-reset-cold

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Start noVNC Session

requires authentication

Initiates a remote IPMI proxy session to the BMC of the device associated with the given service. The proxy allows web-based access to the BMC for remote management tasks like KVM, virtual media, or BIOS configuration.

If a session cannot be established, an error with logs may be returned for debugging purposes.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/ipmi/novnc-connect" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/ipmi/novnc-connect"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/ipmi/novnc-connect';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/ipmi/novnc-connect'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/ipmi/novnc-connect

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Show IPMI console session information

Retrieves session-related data for an active IPMI proxy session

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/ipmi/console/information" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password\": \"3bf5By\",
    \"port\": 5901,
    \"token\": \"1784360e52abb6d874b92747ea9df6fabde33a20\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/ipmi/console/information"
);

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

let body = {
    "password": "3bf5By",
    "port": 5901,
    "token": "1784360e52abb6d874b92747ea9df6fabde33a20"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/ipmi/console/information';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password' => '3bf5By',
            'port' => 5901,
            'token' => '1784360e52abb6d874b92747ea9df6fabde33a20',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/ipmi/console/information'
payload = {
    "password": "3bf5By",
    "port": 5901,
    "token": "1784360e52abb6d874b92747ea9df6fabde33a20"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/ipmi/console/information

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

password   string   

The unique session password used to identify the IPMI proxy session. Example: 3bf5By

port   integer   

The port used for the proxy session. Example: 5901

token   string   

The unique session token used to identify the IPMI proxy session. Example: 1784360e52abb6d874b92747ea9df6fabde33a20

Update IPMI session activity

Updates the updated_at timestamp of an active IPMI proxy session.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/ipmi/console/activity" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password\": \"3bf5By\",
    \"port\": 5901,
    \"token\": \"1784360e52abb6d874b92747ea9df6fabde33a20\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/ipmi/console/activity"
);

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

let body = {
    "password": "3bf5By",
    "port": 5901,
    "token": "1784360e52abb6d874b92747ea9df6fabde33a20"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/ipmi/console/activity';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password' => '3bf5By',
            'port' => 5901,
            'token' => '1784360e52abb6d874b92747ea9df6fabde33a20',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/ipmi/console/activity'
payload = {
    "password": "3bf5By",
    "port": 5901,
    "token": "1784360e52abb6d874b92747ea9df6fabde33a20"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/ipmi/console/activity

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

password   string   

The unique session password used to identify the IPMI proxy session. Example: 3bf5By

port   integer   

The port used for the proxy session. Example: 5901

token   string   

The unique session token used to identify the IPMI proxy session. Example: 1784360e52abb6d874b92747ea9df6fabde33a20

Close IPMI session

Terminates the IPMI proxy session. This is typically used when the user exits the remote console.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/ipmi/console/close" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password\": \"3bf5By\",
    \"port\": 5901,
    \"token\": \"1784360e52abb6d874b92747ea9df6fabde33a20\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/ipmi/console/close"
);

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

let body = {
    "password": "3bf5By",
    "port": 5901,
    "token": "1784360e52abb6d874b92747ea9df6fabde33a20"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/ipmi/console/close';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password' => '3bf5By',
            'port' => 5901,
            'token' => '1784360e52abb6d874b92747ea9df6fabde33a20',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/ipmi/console/close'
payload = {
    "password": "3bf5By",
    "port": 5901,
    "token": "1784360e52abb6d874b92747ea9df6fabde33a20"
}
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/ipmi/console/close

Headers

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

password   string   

The unique session password used to identify the IPMI proxy session. Example: 3bf5By

port   integer   

The port used for the proxy session. Example: 5901

token   string   

The unique session token used to identify the IPMI proxy session. Example: 1784360e52abb6d874b92747ea9df6fabde33a20

DNS Management

List rDNS records

requires authentication

This endpoint returns a paginated list of reverse DNS (rDNS) entries associated with the device assigned to the specified service.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/rdns?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/rdns"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/rdns';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/rdns'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/rdns

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Create rDNS record

requires authentication

Stores a new reverse DNS (rDNS) entry for the device assigned to the given service.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/rdns" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"ip\": \"192.168.1.1\",
    \"rdata\": \"example.mydomain.com\",
    \"ttl\": 3600
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/rdns"
);

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

let body = {
    "ip": "192.168.1.1",
    "rdata": "example.mydomain.com",
    "ttl": 3600
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/rdns';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'ip' => '192.168.1.1',
            'rdata' => 'example.mydomain.com',
            'ttl' => 3600,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/rdns'
payload = {
    "ip": "192.168.1.1",
    "rdata": "example.mydomain.com",
    "ttl": 3600
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/rdns

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Body Parameters

ip   string   

The IP address to associate with the reverse DNS record. Must be a valid IP address. Example: 192.168.1.1

rdata   string   

The domain name (PTR) that should resolve for the IP. Example: example.mydomain.com

ttl   integer  optional  

Optional TTL (Time To Live) value for the record in seconds. Must be at least 60. Example: 3600

Update rDNS record

requires authentication

Updates an existing reverse DNS (rDNS) record.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/rdns/456" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"rdata\": \"updated.example.net\",
    \"ttl\": 3600
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/rdns/456"
);

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

let body = {
    "rdata": "updated.example.net",
    "ttl": 3600
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/rdns/456';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'rdata' => 'updated.example.net',
            'ttl' => 3600,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/rdns/456'
payload = {
    "rdata": "updated.example.net",
    "ttl": 3600
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/rdns/{recordId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

recordId   integer   

The ID of the rDNS record. Example: 456

Body Parameters

rdata   string   

The domain name (PTR) to update for this record. Example: updated.example.net

ttl   integer  optional  

Optional TTL (Time To Live) value in seconds. Must be at least 60. Example: 3600

Delete rDNS record

requires authentication

Deletes a reverse DNS (rDNS) record that belongs to the device assigned to the specified service.

Example request:
curl --request DELETE \
    "https://your-easydcim.com/api/v3/client/services/123/rdns/456" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/rdns/456"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/rdns/456';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/rdns/456'
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

DELETE api/v3/client/services/{id}/rdns/{recordId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

recordId   integer   

The ID of the rDNS record. Example: 456

Two-Factor Authentication

Enable two-factor authentication

requires authentication

Initializes the selected 2FA module for the logged-in client and returns configuration data such as a QR code and secret needed to complete setup.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/two-factor/enable" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"module_name\": \"Totp\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/two-factor/enable"
);

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

let body = {
    "module_name": "Totp"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/two-factor/enable';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'module_name' => 'Totp',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/two-factor/enable'
payload = {
    "module_name": "Totp"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/two-factor/enable

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

module_name   string   

The identifier of the 2FA module to enable. Currently supported: "Totp". Example: Totp

Must be one of:
  • Totp

Disable two-factor authentication

requires authentication

Validates the user's password and, if correct, disables 2FA and removes any stored configuration.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/two-factor/disable" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"password\": \"user_current_password\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/two-factor/disable"
);

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

let body = {
    "password": "user_current_password"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/two-factor/disable';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'password' => 'user_current_password',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/two-factor/disable'
payload = {
    "password": "user_current_password"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/two-factor/disable

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

password   string   

The current password of the user, required to disable two-factor authentication. Example: user_current_password

Store and verify 2FA configuration

requires authentication

Verifies the provided 2FA code and secret, and stores the configuration if verification succeeds. Also returns a backup code for account recovery.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/two-factor/store" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"module_name\": \"Totp\",
    \"configuration\": {
        \"code\": \"123456\",
        \"secret_word\": \"JBSWY3DPEHPK3PXP\"
    }
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/two-factor/store"
);

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

let body = {
    "module_name": "Totp",
    "configuration": {
        "code": "123456",
        "secret_word": "JBSWY3DPEHPK3PXP"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/two-factor/store';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'module_name' => 'Totp',
            'configuration' => [
                'code' => '123456',
                'secret_word' => 'JBSWY3DPEHPK3PXP',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/two-factor/store'
payload = {
    "module_name": "Totp",
    "configuration": {
        "code": "123456",
        "secret_word": "JBSWY3DPEHPK3PXP"
    }
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/two-factor/store

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

module_name   string   

The identifier of the 2FA module to configure. Currently supported: "Totp". Example: Totp

Must be one of:
  • Totp
configuration   object   

Key-value configuration specific to the selected 2FA module. For the "Totp" module, the array must contain the fields: "code" (current token) and "secret_word" (shared secret).

Validate the second-factor authentication code after login

requires authentication

Verifies the submitted 2FA code using the user's default 2FA module. On success, marks the session as 2FA-authenticated.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/two-factor/validate" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"configuration\": {
        \"code\": \"123456\"
    }
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/two-factor/validate"
);

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

let body = {
    "configuration": {
        "code": "123456"
    }
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/two-factor/validate';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'configuration' => [
                'code' => '123456',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/two-factor/validate'
payload = {
    "configuration": {
        "code": "123456"
    }
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/two-factor/validate

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

configuration   object   

Container for second-factor verification data.
code   string   

The 2FA code generated by the authenticator app. Must be at least 4 characters. Must not be greater than 10 characters. Example: 123456

Log in using a backup 2FA code

requires authentication

Validates the backup code stored during 2FA setup and marks the session as verified.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/two-factor/backup-code" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"code\": \"MY-BACKUP-CODE-123\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/two-factor/backup-code"
);

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

let body = {
    "code": "MY-BACKUP-CODE-123"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/two-factor/backup-code';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'code' => 'MY-BACKUP-CODE-123',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/two-factor/backup-code'
payload = {
    "code": "MY-BACKUP-CODE-123"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/two-factor/backup-code

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

Body Parameters

code   string   

The backup code defined during 2FA setup. Must be at least 6 characters. Must not be greater than 255 characters. Example: MY-BACKUP-CODE-123

IP Address Management

List of IP addresses

requires authentication

This endpoint returns a paginated collection of IP addresses associated with the specified service.

Example request:
curl --request GET \
    --get "https://your-easydcim.com/api/v3/client/services/123/ipaddresses?per_page=10&sort_by=name&sort_dir=asc&search_term=SSD" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json"
const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/ipaddresses"
);

const params = {
    "per_page": "10",
    "sort_by": "name",
    "sort_dir": "asc",
    "search_term": "SSD",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/ipaddresses';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'query' => [
            'per_page' => '10',
            'sort_by' => 'name',
            'sort_dir' => 'asc',
            'search_term' => 'SSD',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/ipaddresses'
params = {
  'per_page': '10',
  'sort_by': 'name',
  'sort_dir': 'asc',
  'search_term': 'SSD',
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Example response (401):

Show headers 
cache-control: no-cache, private
content-type: application/json
access-control-allow-origin: *
 

{
    "success": false,
    "status": "error",
    "message": "Unauthenticated."
}

Request   

GET api/v3/client/services/{id}/ipaddresses

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

Query Parameters

per_page   integer  optional  

The number of items per page (min:1, max:100). Example: 10

sort_by   string  optional  

The field to sort by. Must match a sortable field defined in the collection metadata. Example: name

sort_dir   string  optional  

The direction of sorting. Allowed values: asc, desc. Example: asc

search_term   string  optional  

Optional. Filters results by matching words in searchable fields. Example: SSD

Update IP address description

requires authentication

Updates the description of an IP address entity associated with the device assigned to the specified service.

Example request:
curl --request POST \
    "https://your-easydcim.com/api/v3/client/services/123/ipaddresses/456" \
    --header "Authorization: Bearer {YOUR_AUTH_KEY}" \
    --header "Content-Type: application/json" \
    --header "Accept: application/json" \
    --data "{
    \"description\": \"Primary IP for web server\",
    \"ip_address\": \"192.168.56.1\"
}"

const url = new URL(
    "https://your-easydcim.com/api/v3/client/services/123/ipaddresses/456"
);

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

let body = {
    "description": "Primary IP for web server",
    "ip_address": "192.168.56.1"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = 'https://your-easydcim.com/api/v3/client/services/123/ipaddresses/456';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_AUTH_KEY}',
            'Content-Type' => 'application/json',
            'Accept' => 'application/json',
        ],
        'json' => [
            'description' => 'Primary IP for web server',
            'ip_address' => '192.168.56.1',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = 'https://your-easydcim.com/api/v3/client/services/123/ipaddresses/456'
payload = {
    "description": "Primary IP for web server",
    "ip_address": "192.168.56.1"
}
headers = {
  'Authorization': 'Bearer {YOUR_AUTH_KEY}',
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}

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

Request   

POST api/v3/client/services/{id}/ipaddresses/{entityId}

Headers

Authorization      

Example: Bearer {YOUR_AUTH_KEY}

Content-Type      

Example: application/json

Accept      

Example: application/json

URL Parameters

id   integer   

The ID of the service. Example: 123

entityId   integer   

The ID of the IP address entity. Example: 456

Body Parameters

description   string   

Optional description or label for the IP address. Example: Primary IP for web server

ip_address   string   

IP Address for which description will be updated. Example: 192.168.56.1