# Kiteworks API — system Operations

**10 endpoints** | [Browse interactive reference](https://developer.kiteworks.com/api-reference/system.html) | [Download spec slice](https://developer.kiteworks.com/assets/specs/system.json)

> **Authentication required.** All requests must include a Bearer access token in the
> `Authorization` header. See [Authentication](https://developer.kiteworks.com/authentication.md) for how to
> obtain a token using OAuth 2.0 Authorization Code (PKCE) or JWT Bearer flow.

---

## GET /rest/nodeHealth/status

**Summary:** Get node health status for system monitoring

### Description:
  Retrieves node health status information for system components including MariaDB cluster status, required services status, memory usage, and system load average.
### Precondition:
  This endpoint is restricted by IP whitelist and rate limiting.
### Response:
  Returns the overall node health status.
**Responses:**

| Code | Description |
|------|-------------|
| 200 | Node health status returned successfully - all components are healthy. |
| 490 | Request blocked by WAF |
| 500 | ERR_INTERNAL_SERVER_ERROR |
| 503 | Service unavailable - one or more components are unhealthy. |

**Response Examples:**

**200:**

```json
{
  "ok": 1
}
```

**503:**

```json
{
  "ok": 0
}
```

**Code Samples:**

**cURL:**

```shell
curl -X GET \
  "https://{instance}.kiteworks.com/rest/nodeHealth/status" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/nodeHealth/status"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.get(url, headers=headers)
print(response.json())
```

---

## POST /rest/system/epgdb/import/{id}

**Summary:** Upload EPGDB backup chunk for database restore

Endpoint for uploading a chunk to an existing EPGDB backup upload session, identified by its session ID.

**Parameters:**

| Name | In | Required | Description |
|------|----|----------|-------------|
| `id` | path | yes | The upload session ID |

**Request Body:**

| Property | Type | Required | Description |
|----------|------|----------|-------------|
| `filename` | string | yes | The filename of the EPGDB backup file being uploaded. |

**Responses:**

| Code | Description |
|------|-------------|
| 200 | Successfully received the upload |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER |
| 422 | Unprocessable Content  <i>Possible error codes: </i>ERR_INVALID_PARAMETER, ERR_FILE_TOO_LARGE |
| 490 | Request blocked by WAF |
| 503 | Service Unavailable  <i>Possible error codes: </i>ERR_SESSION_LIMIT_REACHED, ERR_UPLOAD_CHUNK_FAILED |
| 507 | Insufficient Storage  <i>Possible error codes: </i>ERR_INSUFFICIENT_DISK_SPACE |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**422 (ERR_INVALID_PARAMETER):**

```json
{
  "errors": [
    {
      "code": "ERR_INVALID_PARAMETER",
      "message": "Invalid Parameter Exception"
    }
  ]
}
```

**422 (ERR_FILE_TOO_LARGE):**

```json
{
  "errors": [
    {
      "code": "ERR_FILE_TOO_LARGE",
      "message": "Size of the file exceeds the allowed limit."
    }
  ]
}
```

**503 (ERR_SESSION_LIMIT_REACHED):**

```json
{
  "errors": [
    {
      "code": "ERR_SESSION_LIMIT_REACHED",
      "message": "Session limit reached. Unable to create a new session."
    }
  ]
}
```

**503 (ERR_UPLOAD_CHUNK_FAILED):**

```json
{
  "errors": [
    {
      "code": "ERR_UPLOAD_CHUNK_FAILED",
      "message": "Upload chunk failed."
    }
  ]
}
```

**507 (ERR_INSUFFICIENT_DISK_SPACE):**

```json
{
  "errors": [
    {
      "code": "ERR_INSUFFICIENT_DISK_SPACE",
      "message": "Server does not have enough storage to process the upload."
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X POST \
  "https://{instance}.kiteworks.com/rest/system/epgdb/import/:id" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
         "filename": "string"
       }'
```

**Python:**

```python
import requests

id = "VALUE"  # The upload session ID

url = f"https://{{instance}}.kiteworks.com/rest/system/epgdb/import/{id}"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
  "filename": "string"
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```

---

## GET /rest/system/epgdb/import

**Summary:** Get EPGDB import status

Endpoint for polling the status of the import
**Responses:**

| Code | Description |
|------|-------------|
| 200 | Successfully returned the import status |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER |
| 422 | Unprocessable Content  <i>Possible error codes: </i>ERR_INVALID_PARAMETER |
| 490 | Request blocked by WAF |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**422 (ERR_INVALID_PARAMETER):**

```json
{
  "errors": [
    {
      "code": "ERR_INVALID_PARAMETER",
      "message": "Invalid Parameter Exception"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X GET \
  "https://{instance}.kiteworks.com/rest/system/epgdb/import" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/system/epgdb/import"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.get(url, headers=headers)
print(response.json())
```

---

## POST /rest/system/epgdb/import

**Summary:** Upload EPGDB backup for database restore

Endpoint for uploading an EPGDB backup for restoring the database. Starts a new upload session.
**Request Body:**

| Property | Type | Required | Description |
|----------|------|----------|-------------|
| `filename` | string | yes | The filename of the EPGDB backup file being uploaded. |

**Responses:**

| Code | Description |
|------|-------------|
| 200 | Successfully received the upload |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER |
| 422 | Unprocessable Content  <i>Possible error codes: </i>ERR_INVALID_PARAMETER, ERR_FILE_TOO_LARGE |
| 490 | Request blocked by WAF |
| 503 | Service Unavailable  <i>Possible error codes: </i>ERR_SESSION_LIMIT_REACHED, ERR_UPLOAD_CHUNK_FAILED |
| 507 | Insufficient Storage  <i>Possible error codes: </i>ERR_INSUFFICIENT_DISK_SPACE |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**422 (ERR_INVALID_PARAMETER):**

```json
{
  "errors": [
    {
      "code": "ERR_INVALID_PARAMETER",
      "message": "Invalid Parameter Exception"
    }
  ]
}
```

**422 (ERR_FILE_TOO_LARGE):**

```json
{
  "errors": [
    {
      "code": "ERR_FILE_TOO_LARGE",
      "message": "Size of the file exceeds the allowed limit."
    }
  ]
}
```

**503 (ERR_SESSION_LIMIT_REACHED):**

```json
{
  "errors": [
    {
      "code": "ERR_SESSION_LIMIT_REACHED",
      "message": "Session limit reached. Unable to create a new session."
    }
  ]
}
```

**503 (ERR_UPLOAD_CHUNK_FAILED):**

```json
{
  "errors": [
    {
      "code": "ERR_UPLOAD_CHUNK_FAILED",
      "message": "Upload chunk failed."
    }
  ]
}
```

**507 (ERR_INSUFFICIENT_DISK_SPACE):**

```json
{
  "errors": [
    {
      "code": "ERR_INSUFFICIENT_DISK_SPACE",
      "message": "Server does not have enough storage to process the upload."
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X POST \
  "https://{instance}.kiteworks.com/rest/system/epgdb/import" \
  -H "Authorization: Bearer YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
         "filename": "string"
       }'
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/system/epgdb/import"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
    "Content-Type": "application/json",
}
payload = {
  "filename": "string"
}
response = requests.post(url, headers=headers, json=payload)
print(response.json())
```

---

## DELETE /rest/system/epgdb/import

**Summary:** Cancel active EPGDB import session

Endpoint for cancelling the current active import session
**Responses:**

| Code | Description |
|------|-------------|
| 200 | Successfully deleted the session |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER |
| 490 | Request blocked by WAF |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X DELETE \
  "https://{instance}.kiteworks.com/rest/system/epgdb/import" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/system/epgdb/import"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.delete(url, headers=headers)
print(response.json())
```

---

## GET /rest/system/epgdb/export/{filename}

**Summary:** Download EPGDB export file

Get EPGDB export download

**Parameters:**

| Name | In | Required | Description |
|------|----|----------|-------------|
| `filename` | path | yes | The name of the EPGDB export file to download. |

**Responses:**

| Code | Description |
|------|-------------|
| 200 | EPGDB export download |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER, ERR_DB_BACKUP_FAILED |
| 490 | Request blocked by WAF |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**403 (ERR_DB_BACKUP_FAILED):**

```json
{
  "errors": [
    {
      "code": "ERR_DB_BACKUP_FAILED",
      "message": "Database backup failed due to an unexpected error"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X GET \
  "https://{instance}.kiteworks.com/rest/system/epgdb/export/:filename" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

filename = "VALUE"  # The name of the EPGDB export file to download.

url = f"https://{{instance}}.kiteworks.com/rest/system/epgdb/export/{filename}"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.get(url, headers=headers)
print(response.json())
```

---

## GET /rest/system/epgdb/export

**Summary:** Get EPGDB export status

Get EPGDB export status
**Responses:**

| Code | Description |
|------|-------------|
| 200 | EPGDB export status returned successfully |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER |
| 490 | Request blocked by WAF |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X GET \
  "https://{instance}.kiteworks.com/rest/system/epgdb/export" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/system/epgdb/export"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.get(url, headers=headers)
print(response.json())
```

---

## POST /rest/system/epgdb/export

**Summary:** Start EPGDB export

Start EPGDB export with precheck validation
**Responses:**

| Code | Description |
|------|-------------|
| 200 | EPGDB export started successfully |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER, ERR_JOB_IN_PROGRESS |
| 404 | Not Found  <i>Possible error codes: </i>ERR_EPGDB_NOT_FOUND |
| 490 | Request blocked by WAF |
| 507 | Insufficient Storage  <i>Possible error codes: </i>ERR_INSUFFICIENT_TMP_STORAGE |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**403 (ERR_JOB_IN_PROGRESS):**

```json
{
  "errors": [
    {
      "code": "ERR_JOB_IN_PROGRESS",
      "message": "The job is currently still in progress"
    }
  ]
}
```

**404 (ERR_EPGDB_NOT_FOUND):**

```json
{
  "errors": [
    {
      "code": "ERR_EPGDB_NOT_FOUND",
      "message": "Failed to locate EPGDB"
    }
  ]
}
```

**507 (ERR_INSUFFICIENT_TMP_STORAGE):**

```json
{
  "errors": [
    {
      "code": "ERR_INSUFFICIENT_TMP_STORAGE",
      "message": "Insufficient storage space in the Tmp storage partition"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X POST \
  "https://{instance}.kiteworks.com/rest/system/epgdb/export" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/system/epgdb/export"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.post(url, headers=headers)
print(response.json())
```

---

## DELETE /rest/system/epgdb/export

**Summary:** Perform cleanup for EPGDB export

Perform cleanup for EPGDB export
**Responses:**

| Code | Description |
|------|-------------|
| 200 | Delete EPGDB export |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 403 | Forbidden  <i>Possible error codes: </i>ERR_ACCESS_DENIED, ERR_ACCESS_USER, ERR_JOB_IN_PROGRESS |
| 490 | Request blocked by WAF |

**Response Examples:**

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**403 (ERR_ACCESS_DENIED):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_DENIED",
      "message": "Your access is denied.",
      "redirectUrl": "/login?code=3317"
    }
  ]
}
```

**403 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**403 (ERR_JOB_IN_PROGRESS):**

```json
{
  "errors": [
    {
      "code": "ERR_JOB_IN_PROGRESS",
      "message": "The job is currently still in progress"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X DELETE \
  "https://{instance}.kiteworks.com/rest/system/epgdb/export" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

url = "https://{instance}.kiteworks.com/rest/system/epgdb/export"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.delete(url, headers=headers)
print(response.json())
```

---

## GET /rest/nodeHealth/{node_id}/metrics/{metric_name}

**Summary:** Get node health metrics for specified metric type

### Description:
  Retrieves health metrics for database, web requests, job queue, SFTP, system resources, or all metrics.
### Precondition:
  The user must be an administrator with access to `System Services`.
### Response:
  Returns the list of metrics for the specified metric type.

**Parameters:**

| Name | In | Required | Description |
|------|----|----------|-------------|
| `node_id` | path | yes | Kiteworks node id to retrieve metrics from. |
| `metric_name` | path | yes | The type of metric to retrieve. |

**Responses:**

| Code | Description |
|------|-------------|
| 200 | The node health metrics have been successfully returned. |
| 401 | Unauthorized  <i>Possible error codes: </i>ERR_ACCESS_USER, ERR_AUTH_INVALID_CSRF, ERR_AUTH_UNAUTHORIZED |
| 422 | Unprocessable Content  <i>Possible error codes: </i>ERR_INVALID_PARAMETER |
| 490 | Request blocked by WAF |
| 500 | Internal Server Error  <i>Possible error codes: </i>ERR_INTERNAL_SERVER_ERROR |

**Response Examples:**

**401 (ERR_ACCESS_USER):**

```json
{
  "errors": [
    {
      "code": "ERR_ACCESS_USER",
      "message": "Insufficient access permissions"
    }
  ]
}
```

**401 (ERR_AUTH_INVALID_CSRF):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_INVALID_CSRF",
      "message": "Invalid CSRF Authentication"
    }
  ]
}
```

**401 (ERR_AUTH_UNAUTHORIZED):**

```json
{
  "errors": [
    {
      "code": "ERR_AUTH_UNAUTHORIZED",
      "message": "Unauthorized"
    }
  ]
}
```

**422 (ERR_INVALID_PARAMETER):**

```json
{
  "errors": [
    {
      "code": "ERR_INVALID_PARAMETER",
      "message": "Invalid Parameter Exception"
    }
  ]
}
```

**500 (ERR_INTERNAL_SERVER_ERROR):**

```json
{
  "errors": [
    {
      "code": "ERR_INTERNAL_SERVER_ERROR",
      "message": "Internal Server Error"
    }
  ]
}
```

**Code Samples:**

**cURL:**

```shell
curl -X GET \
  "https://{instance}.kiteworks.com/rest/nodeHealth/:node_id/metrics/:metric_name" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

**Python:**

```python
import requests

node_id = "VALUE"  # Kiteworks node id to retrieve metrics from.
metric_name = "VALUE"  # The type of metric to retrieve.

url = f"https://{{instance}}.kiteworks.com/rest/nodeHealth/{node_id}/metrics/{metric_name}"
headers = {
    "Authorization": "Bearer YOUR_TOKEN",
}
response = requests.get(url, headers=headers)
print(response.json())
```

---