MENU navbar-image

Introduction

This documentation aims to provide all the information you need to work with our API. The documentation is work in progress and it's currently missing proper examples.

Authenticating requests

To authenticate requests, include an Authorization header with your API Token, example: Authorization: Bearer {YOUR_API_TOKEN}

To call user endpoints, include additional X-PanelAlpha-User header with the user's ID, example: X-PanelAlpha-User: 12

You can retrieve your token in Configuration -> Admins section of admin area.

Admin Endpoints

System

Show system configuration

Example request:
curl --request GET \
    --get "/api/admin/settings" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/settings"
);

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

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

url = '/api/admin/settings'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/settings

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Update system configuration

Example request:
curl --request PUT \
    "/api/admin/settings" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/settings"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/settings';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/settings'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/settings

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

SSL

List SSL providers

Example request:
curl --request GET \
    --get "/api/admin/ssl/providers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/ssl/providers"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/ssl/providers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/ssl/providers'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/ssl/providers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List SSL orders

Example request:
curl --request GET \
    --get "/api/admin/ssl-orders" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/ssl-orders"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/ssl-orders';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/ssl-orders'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/ssl-orders

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List SSL logs

Example request:
curl --request GET \
    --get "/api/admin/ssl-orders/logs" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/ssl-orders/logs"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/ssl-orders/logs';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/ssl-orders/logs'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/ssl-orders/logs

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Process SSL order

Example request:
curl --request PUT \
    "/api/admin/ssl-orders/13/process" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/ssl-orders/13/process"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/ssl-orders/13/process';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/ssl-orders/13/process'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/ssl-orders/{id}/process

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

SSL order ID. Example: 13

Abandon SSL Order

Example request:
curl --request PUT \
    "/api/admin/ssl-orders/7/abandon" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/ssl-orders/7/abandon"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/ssl-orders/7/abandon';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/ssl-orders/7/abandon'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/ssl-orders/{id}/abandon

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

SSL order ID. Example: 7

Users

List users

Example request:
curl --request GET \
    --get "/api/admin/users" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": \"excepturi\"
}"
const url = new URL(
    "/api/admin/users"
);

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

let body = {
    "filter": "excepturi"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => 'excepturi',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users'
payload = {
    "filter": "excepturi"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

filter   string  optional  

Example: excepturi

Create user

Example request:
curl --request POST \
    "/api/admin/users" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"first_name\": \"nmfrakqcgbm\",
    \"last_name\": \"q\",
    \"company_name\": \"yoydmnqpe\",
    \"email\": \"[email protected]\",
    \"password\": \"$,~~D}vI*\"
}"
const url = new URL(
    "/api/admin/users"
);

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

let body = {
    "first_name": "nmfrakqcgbm",
    "last_name": "q",
    "company_name": "yoydmnqpe",
    "email": "[email protected]",
    "password": "$,~~D}vI*"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'first_name' => 'nmfrakqcgbm',
            'last_name' => 'q',
            'company_name' => 'yoydmnqpe',
            'email' => '[email protected]',
            'password' => '$,~~D}vI*',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users'
payload = {
    "first_name": "nmfrakqcgbm",
    "last_name": "q",
    "company_name": "yoydmnqpe",
    "email": "[email protected]",
    "password": "$,~~D}vI*"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/users

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

first_name   string  optional  

Must not be greater than 255 characters. Example: nmfrakqcgbm

last_name   string  optional  

Must not be greater than 255 characters. Example: q

company_name   string  optional  

Must not be greater than 255 characters. Example: yoydmnqpe

email   string   

Must be a valid email address. Must not be greater than 255 characters. Example: [email protected]

password   string   

Must be at least 8 characters. Example: $,~~D}vI*

List archived users

Example request:
curl --request GET \
    --get "/api/admin/users/archived" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/archived"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/archived';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/archived'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/archived

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Find user by email

Example request:
curl --request GET \
    --get "/api/admin/users/email?email=user%40example.com" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/email"
);

const params = {
    "email": "[email protected]",
};
Object.keys(params)
    .forEach(key => url.searchParams.append(key, params[key]));

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/email';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'query' => [
            'email' => '[email protected]',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/email'
params = {
  'email': '[email protected]',
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/email

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Query Parameters

email   string   

Email address. Example: [email protected]

Show archived user details

Example request:
curl --request GET \
    --get "/api/admin/users/12/archived" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/12/archived"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/12/archived';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/12/archived'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{id}/archived

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 12

Show user details

Example request:
curl --request GET \
    --get "/api/admin/users/20" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/20"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/20';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/20'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 20

Get user's last activity

Example request:
curl --request GET \
    --get "/api/admin/users/10/last-activity" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/10/last-activity"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/10/last-activity';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/10/last-activity'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{id}/last-activity

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 10

Unarchive user

Example request:
curl --request PUT \
    "/api/admin/users/17/unarchive" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/17/unarchive"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/17/unarchive';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/17/unarchive'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/users/{id}/unarchive

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 17

Update user

Example request:
curl --request PUT \
    "/api/admin/users/4" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"first_name\": \"rq\",
    \"last_name\": \"wjqvoxpbsyndwnvwjakhon\",
    \"company_name\": \"dskyty\",
    \"email\": \"[email protected]\",
    \"password\": \"m)W0CpAV^K@0ul+\'a{H\"
}"
const url = new URL(
    "/api/admin/users/4"
);

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

let body = {
    "first_name": "rq",
    "last_name": "wjqvoxpbsyndwnvwjakhon",
    "company_name": "dskyty",
    "email": "[email protected]",
    "password": "m)W0CpAV^K@0ul+'a{H"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/4';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'first_name' => 'rq',
            'last_name' => 'wjqvoxpbsyndwnvwjakhon',
            'company_name' => 'dskyty',
            'email' => '[email protected]',
            'password' => 'm)W0CpAV^K@0ul+\'a{H',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/4'
payload = {
    "first_name": "rq",
    "last_name": "wjqvoxpbsyndwnvwjakhon",
    "company_name": "dskyty",
    "email": "[email protected]",
    "password": "m)W0CpAV^K@0ul+'a{H"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/users/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 4

Body Parameters

first_name   string  optional  

Must not be greater than 255 characters. Example: rq

last_name   string  optional  

Must not be greater than 255 characters. Example: wjqvoxpbsyndwnvwjakhon

company_name   string  optional  

Must not be greater than 255 characters. Example: dskyty

email   string   

Must be a valid email address. Must not be greater than 255 characters. Example: [email protected]

password   string  optional  

Must be at least 8 characters. Example: m)W0CpAV^K@0ul+'a{H

Delete archived user

Example request:
curl --request DELETE \
    "/api/admin/users/1/delete" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/1/delete"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/1/delete';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/1/delete'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/users/{id}/delete

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 1

Delete user

Example request:
curl --request DELETE \
    "/api/admin/users/8" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/8"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/8';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/8'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/users/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 8

Create user SSO token

Example request:
curl --request POST \
    "/api/admin/users/3/sso-token" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/3/sso-token"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/3/sso-token';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/3/sso-token'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/users/{id}/sso-token

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 3

Create admin-as-user SSO token

Example request:
curl --request POST \
    "/api/admin/users/14/login-as-user-sso-token" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/14/login-as-user-sso-token"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/14/login-as-user-sso-token';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/14/login-as-user-sso-token'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/users/{id}/login-as-user-sso-token

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 14

List users with shared instances access

Example request:
curl --request GET \
    --get "/api/admin/users/7/sharing-with" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/7/sharing-with"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/7/sharing-with';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/7/sharing-with'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{id}/sharing-with

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 7

List instances shared with user

Example request:
curl --request GET \
    --get "/api/admin/users/5/sharing-with/3/shared-instances" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/5/sharing-with/3/shared-instances"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/5/sharing-with/3/shared-instances';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/5/sharing-with/3/shared-instances'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{id}/sharing-with/{sharingWithId}/shared-instances

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 5

sharingWithId   integer   

User ID. Example: 3

List all instances

Returns all instances the user has access to.

Example request:
curl --request GET \
    --get "/api/admin/users/15/all-instances" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/15/all-instances"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/15/all-instances';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/15/all-instances'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{id}/all-instances

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

User ID. Example: 15

List user services

Example request:
curl --request GET \
    --get "/api/admin/users/12/services" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/12/services"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/12/services';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/12/services'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/users/{userId}/services

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

userId   integer   

User ID. Example: 12

Create user service

Example request:
curl --request POST \
    "/api/admin/users/17/services" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"plan_id\": 8
}"
const url = new URL(
    "/api/admin/users/17/services"
);

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

let body = {
    "plan_id": 8
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/17/services';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'plan_id' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/17/services'
payload = {
    "plan_id": 8
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/users/{userId}/services

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

userId   integer   

User ID. Example: 17

Body Parameters

plan_id   integer   

Example: 8

Suspend user service

Example request:
curl --request PUT \
    "/api/admin/users/15/services/16/suspend" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/15/services/16/suspend"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/15/services/16/suspend';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/15/services/16/suspend'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/users/{userId}/services/{id}/suspend

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

userId   integer   

User ID. Example: 15

id   integer   

Service ID. Example: 16

Unsuspend user service

Example request:
curl --request PUT \
    "/api/admin/users/12/services/7/unsuspend" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/12/services/7/unsuspend"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/12/services/7/unsuspend';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/12/services/7/unsuspend'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/users/{userId}/services/{id}/unsuspend

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

userId   integer   

User ID. Example: 12

id   integer   

Service ID. Example: 7

Change user service's plan

Example request:
curl --request PUT \
    "/api/admin/users/11/services/1/change-plan" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"plan_id\": 11
}"
const url = new URL(
    "/api/admin/users/11/services/1/change-plan"
);

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

let body = {
    "plan_id": 11
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/11/services/1/change-plan';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'plan_id' => 11,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/11/services/1/change-plan'
payload = {
    "plan_id": 11
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/users/{userId}/services/{id}/change-plan

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

userId   integer   

User ID. Example: 11

id   integer   

Service ID. Example: 1

Body Parameters

plan_id   integer   

Example: 11

Delete user service

Example request:
curl --request DELETE \
    "/api/admin/users/6/services/18" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/users/6/services/18"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/users/6/services/18';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/users/6/services/18'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/users/{userId}/services/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

userId   integer   

User ID. Example: 6

id   integer   

Service ID. Example: 18

Admins

List admin accounts

Example request:
curl --request GET \
    --get "/api/admin/admins" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admins"
);

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

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

url = '/api/admin/admins'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/admins

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Add admin account

Example request:
curl --request POST \
    "/api/admin/admins" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"ynlzqjssfalggzkcmpduf\",
    \"admin_group_id\": 19,
    \"email\": \"[email protected]\",
    \"password\": \".$lQs-,\"
}"
const url = new URL(
    "/api/admin/admins"
);

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

let body = {
    "name": "ynlzqjssfalggzkcmpduf",
    "admin_group_id": 19,
    "email": "[email protected]",
    "password": ".$lQs-,"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admins';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'ynlzqjssfalggzkcmpduf',
            'admin_group_id' => 19,
            'email' => '[email protected]',
            'password' => '.$lQs-,',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admins'
payload = {
    "name": "ynlzqjssfalggzkcmpduf",
    "admin_group_id": 19,
    "email": "[email protected]",
    "password": ".$lQs-,"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/admins

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Must not be greater than 255 characters. Example: ynlzqjssfalggzkcmpduf

admin_group_id   integer   

Example: 19

email   string   

Must be a valid email address. Must not be greater than 255 characters. Example: [email protected]

password   string   

Must be at least 8 characters. Example: .$lQs-,

Show admin account details

Example request:
curl --request GET \
    --get "/api/admin/admins/7" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admins/7"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admins/7';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admins/7'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/admins/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin ID. Example: 7

Update admin account

Example request:
curl --request PUT \
    "/api/admin/admins/1" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"yorplftxxjrae\",
    \"admin_group_id\": 15,
    \"email\": \"[email protected]\",
    \"password\": \"-b_jNP\"
}"
const url = new URL(
    "/api/admin/admins/1"
);

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

let body = {
    "name": "yorplftxxjrae",
    "admin_group_id": 15,
    "email": "[email protected]",
    "password": "-b_jNP"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admins/1';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'yorplftxxjrae',
            'admin_group_id' => 15,
            'email' => '[email protected]',
            'password' => '-b_jNP',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admins/1'
payload = {
    "name": "yorplftxxjrae",
    "admin_group_id": 15,
    "email": "[email protected]",
    "password": "-b_jNP"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/admins/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin ID. Example: 1

Body Parameters

name   string   

Must not be greater than 255 characters. Example: yorplftxxjrae

admin_group_id   integer   

Example: 15

email   string  optional  

Must be a valid email address. Must not be greater than 255 characters. Example: [email protected]

password   string  optional  

Must be at least 8 characters. Example: -b_jNP

Delete admin account

Example request:
curl --request DELETE \
    "/api/admin/admins/11" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admins/11"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admins/11';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admins/11'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/admins/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin ID. Example: 11

Change admin account status

Example request:
curl --request PUT \
    "/api/admin/admins/10/status" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"disabled\": false
}"
const url = new URL(
    "/api/admin/admins/10/status"
);

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

let body = {
    "disabled": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admins/10/status';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'disabled' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admins/10/status'
payload = {
    "disabled": false
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/admins/{id}/status

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin ID. Example: 10

Body Parameters

disabled   boolean   

Example: false

Enable API token

Example request:
curl --request POST \
    "/api/admin/api-tokens/6" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/api-tokens/6"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/api-tokens/6';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/api-tokens/6'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/api-tokens/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin ID. Example: 6

Disable API token

Example request:
curl --request DELETE \
    "/api/admin/api-tokens/3" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/api-tokens/3"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/api-tokens/3';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/api-tokens/3'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/api-tokens/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin ID. Example: 3

Hosting Servers

Test connection

Example request:
curl --request POST \
    "/api/admin/servers/test-connection" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"type\": \"nemo\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/servers/test-connection"
);

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

let body = {
    "type": "nemo",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/test-connection';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'nemo',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/test-connection'
payload = {
    "type": "nemo",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/servers/test-connection

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

type   string   

Example: nemo

connection_config   object   

Test WP-CLI

Example request:
curl --request POST \
    "/api/admin/servers/test-wp-cli" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"type\": \"mollitia\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/servers/test-wp-cli"
);

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

let body = {
    "type": "mollitia",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/test-wp-cli';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'mollitia',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/test-wp-cli'
payload = {
    "type": "mollitia",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/servers/test-wp-cli

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

type   string   

Example: mollitia

connection_config   object   

List server types

Example request:
curl --request GET \
    --get "/api/admin/servers/types" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/types"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/types'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/types

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Show server type details

Example request:
curl --request GET \
    --get "/api/admin/servers/types/cpanel" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/types/cpanel"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/types/cpanel';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/types/cpanel'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/types/{type}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

type   string   

Server type. Example: cpanel

List server logs

Example request:
curl --request GET \
    --get "/api/admin/servers/logs" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/logs"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/logs';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/logs'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/logs

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List servers

Example request:
curl --request GET \
    --get "/api/admin/servers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"group_id\": 3
}"
const url = new URL(
    "/api/admin/servers"
);

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

let body = {
    "group_id": 3
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'group_id' => 3,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers'
payload = {
    "group_id": 3
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

group_id   integer  optional  

Example: 3

Show server details

Example request:
curl --request GET \
    --get "/api/admin/servers/1" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/1"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/1';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/1'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 1

Show server config

Example request:
curl --request GET \
    --get "/api/admin/servers/14/config" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/14/config"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/14/config';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/14/config'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/{id}/config

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 14

Add server

Example request:
curl --request POST \
    "/api/admin/servers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"consequuntur\",
    \"type\": \"deleniti\",
    \"connection_config\": [],
    \"server_groups\": [
        \"in\"
    ]
}"
const url = new URL(
    "/api/admin/servers"
);

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

let body = {
    "name": "consequuntur",
    "type": "deleniti",
    "connection_config": [],
    "server_groups": [
        "in"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'consequuntur',
            'type' => 'deleniti',
            'connection_config' => [],
            'server_groups' => [
                'in',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers'
payload = {
    "name": "consequuntur",
    "type": "deleniti",
    "connection_config": [],
    "server_groups": [
        "in"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/servers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: consequuntur

type   string   

Example: deleniti

connection_config   object   
server_groups   integer[]   
id   integer   

Example: 16

name   string   

Example: in

server_type   string   

Example: quas

Update server

Example request:
curl --request PUT \
    "/api/admin/servers/8" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"dolores\",
    \"type\": \"ut\",
    \"connection_config\": [],
    \"server_groups\": [
        \"voluptates\"
    ]
}"
const url = new URL(
    "/api/admin/servers/8"
);

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

let body = {
    "name": "dolores",
    "type": "ut",
    "connection_config": [],
    "server_groups": [
        "voluptates"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/8';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'dolores',
            'type' => 'ut',
            'connection_config' => [],
            'server_groups' => [
                'voluptates',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/8'
payload = {
    "name": "dolores",
    "type": "ut",
    "connection_config": [],
    "server_groups": [
        "voluptates"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 8

Body Parameters

name   string   

Example: dolores

type   string   

Example: ut

connection_config   object   
server_groups   integer[]   
id   integer   

Example: 9

name   string   

Example: inventore

server_type   string   

Example: commodi

Delete server

Example request:
curl --request DELETE \
    "/api/admin/servers/8" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/8"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/8';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/8'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 8

List PHP versions

Example request:
curl --request GET \
    --get "/api/admin/servers/3/php/versions" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/3/php/versions"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/3/php/versions';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/3/php/versions'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/{id}/php/versions

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 3

List remote accounts

Example request:
curl --request GET \
    --get "/api/admin/servers/6/sync/accounts" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/6/sync/accounts"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/6/sync/accounts';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/6/sync/accounts'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/{id}/sync/accounts

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 6

Import service

Example request:
curl --request POST \
    "/api/admin/servers/10/sync/import-service" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"username\": \"dolor\",
    \"user_id\": 2,
    \"plan_id\": 5
}"
const url = new URL(
    "/api/admin/servers/10/sync/import-service"
);

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

let body = {
    "username": "dolor",
    "user_id": 2,
    "plan_id": 5
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/10/sync/import-service';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'username' => 'dolor',
            'user_id' => 2,
            'plan_id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/10/sync/import-service'
payload = {
    "username": "dolor",
    "user_id": 2,
    "plan_id": 5
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/servers/{id}/sync/import-service

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 10

Body Parameters

username   string   

Example: dolor

user_id   integer   

Example: 2

plan_id   integer   

Example: 5

Find WordPress installations

Example request:
curl --request GET \
    --get "/api/admin/servers/9/sync/find-applications" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/servers/9/sync/find-applications"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/9/sync/find-applications';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/9/sync/find-applications'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/servers/{id}/sync/find-applications

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 9

Import WordPress installation

Example request:
curl --request POST \
    "/api/admin/servers/18/sync/import-instance" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"username\": \"animi\",
    \"domain\": \"odio\",
    \"path\": \"illum\",
    \"application\": \"et\"
}"
const url = new URL(
    "/api/admin/servers/18/sync/import-instance"
);

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

let body = {
    "username": "animi",
    "domain": "odio",
    "path": "illum",
    "application": "et"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/servers/18/sync/import-instance';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'username' => 'animi',
            'domain' => 'odio',
            'path' => 'illum',
            'application' => 'et',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/servers/18/sync/import-instance'
payload = {
    "username": "animi",
    "domain": "odio",
    "path": "illum",
    "application": "et"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/servers/{id}/sync/import-instance

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server ID. Example: 18

Body Parameters

username   string   

Example: animi

domain   string   

Example: odio

path   string   

Example: illum

application   string  optional  

Example: et

List server groups

Example request:
curl --request GET \
    --get "/api/admin/server-groups" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/server-groups"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/server-groups';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/server-groups'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/server-groups

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Show server group details

Example request:
curl --request GET \
    --get "/api/admin/server-groups/11" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/server-groups/11"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/server-groups/11';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/server-groups/11'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/server-groups/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server group ID. Example: 11

Create server group

Example request:
curl --request POST \
    "/api/admin/server-groups" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"quas\",
    \"server_type\": \"aut\"
}"
const url = new URL(
    "/api/admin/server-groups"
);

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

let body = {
    "name": "quas",
    "server_type": "aut"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/server-groups';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'quas',
            'server_type' => 'aut',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/server-groups'
payload = {
    "name": "quas",
    "server_type": "aut"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/server-groups

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: quas

server_type   string   

Example: aut

servers   object  optional  

Update server group

Example request:
curl --request PUT \
    "/api/admin/server-groups/20" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"ea\",
    \"server_type\": \"maxime\"
}"
const url = new URL(
    "/api/admin/server-groups/20"
);

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

let body = {
    "name": "ea",
    "server_type": "maxime"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/server-groups/20';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'ea',
            'server_type' => 'maxime',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/server-groups/20'
payload = {
    "name": "ea",
    "server_type": "maxime"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/server-groups/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server group ID. Example: 20

Body Parameters

name   string   

Example: ea

server_type   string   

Example: maxime

servers   object  optional  

Delete server group

Example request:
curl --request DELETE \
    "/api/admin/server-groups/11" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/server-groups/11"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/server-groups/11';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/server-groups/11'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/server-groups/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Server group ID. Example: 11

DNS Servers

Test connection

Example request:
curl --request POST \
    "/api/admin/dns-servers/test-connection" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"veniam\",
    \"type\": \"maxime\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/dns-servers/test-connection"
);

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

let body = {
    "name": "veniam",
    "type": "maxime",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/test-connection';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'veniam',
            'type' => 'maxime',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/test-connection'
payload = {
    "name": "veniam",
    "type": "maxime",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/dns-servers/test-connection

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: veniam

type   string   

Example: maxime

connection_config   object   

List DNS server types

Example request:
curl --request GET \
    --get "/api/admin/dns-servers/types" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-servers/types"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/types'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/dns-servers/types

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List DNS servers

Example request:
curl --request GET \
    --get "/api/admin/dns-servers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"type\": \"voluptate\"
}"
const url = new URL(
    "/api/admin/dns-servers"
);

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

let body = {
    "type": "voluptate"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'voluptate',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers'
payload = {
    "type": "voluptate"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/dns-servers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

type   string  optional  

Example: voluptate

Show DNS server details

Example request:
curl --request GET \
    --get "/api/admin/dns-servers/18" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-servers/18"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/18';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/18'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/dns-servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

DNS server ID. Example: 18

Add DNS server

Example request:
curl --request POST \
    "/api/admin/dns-servers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"qui\",
    \"type\": \"optio\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/dns-servers"
);

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

let body = {
    "name": "qui",
    "type": "optio",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'qui',
            'type' => 'optio',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers'
payload = {
    "name": "qui",
    "type": "optio",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/dns-servers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: qui

type   string   

Example: optio

connection_config   object   

Update DNS server

Example request:
curl --request PUT \
    "/api/admin/dns-servers/9" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"vitae\",
    \"type\": \"ea\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/dns-servers/9"
);

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

let body = {
    "name": "vitae",
    "type": "ea",
    "connection_config": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/9';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'vitae',
            'type' => 'ea',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/9'
payload = {
    "name": "vitae",
    "type": "ea",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/dns-servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

DNS server ID. Example: 9

Body Parameters

name   string   

Example: vitae

type   string   

Example: ea

connection_config   object   

Delete DNS server

Example request:
curl --request DELETE \
    "/api/admin/dns-servers/6" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-servers/6"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/6';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/6'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/dns-servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

DNS server ID. Example: 6

List remote DNS zones

Example request:
curl --request GET \
    --get "/api/admin/dns-servers/6/sync/zones" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-servers/6/sync/zones"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/6/sync/zones';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/6/sync/zones'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/dns-servers/{id}/sync/zones

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

DNS server ID. Example: 6

Import DNS zone

Example request:
curl --request POST \
    "/api/admin/dns-servers/14/sync/import-zone" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"in\",
    \"service_id\": 6
}"
const url = new URL(
    "/api/admin/dns-servers/14/sync/import-zone"
);

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

let body = {
    "name": "in",
    "service_id": 6
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-servers/14/sync/import-zone';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'in',
            'service_id' => 6,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-servers/14/sync/import-zone'
payload = {
    "name": "in",
    "service_id": 6
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/dns-servers/{id}/sync/import-zone

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

DNS server ID. Example: 14

Body Parameters

name   string   

Example: in

service_id   integer   

Example: 6

List DNS zone templates

Example request:
curl --request GET \
    --get "/api/admin/dns-zone-templates" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-zone-templates"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-zone-templates';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-zone-templates'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/dns-zone-templates

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Create DNS zone template

Example request:
curl --request POST \
    "/api/admin/dns-zone-template" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"ut\",
    \"records\": [
        \"culpa\"
    ]
}"
const url = new URL(
    "/api/admin/dns-zone-template"
);

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

let body = {
    "name": "ut",
    "records": [
        "culpa"
    ]
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-zone-template';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'ut',
            'records' => [
                'culpa',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-zone-template'
payload = {
    "name": "ut",
    "records": [
        "culpa"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/dns-zone-template

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: ut

records   string[]  optional  
name   string   

Example: necessitatibus

type   string   

Example: NS

Must be one of:
  • A
  • AAAA
  • CNAME
  • TXT
  • MX
  • NS
ttl   integer   

Example: 1

rdata   string   

Example: laudantium

Update DNS zone template

Example request:
curl --request PUT \
    "/api/admin/dns-zone-template/4" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"qui\",
    \"records\": [
        \"ut\"
    ]
}"
const url = new URL(
    "/api/admin/dns-zone-template/4"
);

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

let body = {
    "name": "qui",
    "records": [
        "ut"
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-zone-template/4';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'qui',
            'records' => [
                'ut',
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-zone-template/4'
payload = {
    "name": "qui",
    "records": [
        "ut"
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/dns-zone-template/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Zone template ID. Example: 4

Body Parameters

name   string   

Example: qui

records   string[]  optional  
name   string   

Example: hic

type   string   

Example: TXT

Must be one of:
  • A
  • AAAA
  • CNAME
  • TXT
  • MX
  • NS
ttl   integer   

Example: 9

rdata   string   

Example: qui

Delete zone template

Example request:
curl --request DELETE \
    "/api/admin/dns-zone-template/20" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-zone-template/20"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-zone-template/20';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-zone-template/20'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/dns-zone-template/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Zone template ID. Example: 20

List DNS zones

Example request:
curl --request GET \
    --get "/api/admin/dns-zones" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/dns-zones"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/dns-zones';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/dns-zones'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/dns-zones

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Email Servers

Test connection

Example request:
curl --request POST \
    "/api/admin/email-servers/test-connection" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"omnis\",
    \"type\": \"harum\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/email-servers/test-connection"
);

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

let body = {
    "name": "omnis",
    "type": "harum",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/test-connection';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'omnis',
            'type' => 'harum',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/test-connection'
payload = {
    "name": "omnis",
    "type": "harum",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/email-servers/test-connection

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: omnis

type   string   

Example: harum

connection_config   object   

List email server types

Example request:
curl --request GET \
    --get "/api/admin/email-servers/types" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/email-servers/types"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/types'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/email-servers/types

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List email servers

Example request:
curl --request GET \
    --get "/api/admin/email-servers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"type\": \"dolores\"
}"
const url = new URL(
    "/api/admin/email-servers"
);

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

let body = {
    "type": "dolores"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'type' => 'dolores',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers'
payload = {
    "type": "dolores"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/email-servers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

type   string  optional  

Example: dolores

Show email server details

Example request:
curl --request GET \
    --get "/api/admin/email-servers/in" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/email-servers/in"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/in';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/in'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/email-servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the email server. Example: in

Add email server

Example request:
curl --request POST \
    "/api/admin/email-servers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"provident\",
    \"type\": \"unde\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/email-servers"
);

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

let body = {
    "name": "provident",
    "type": "unde",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'provident',
            'type' => 'unde',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers'
payload = {
    "name": "provident",
    "type": "unde",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/email-servers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: provident

type   string   

Example: unde

connection_config   object   

Update email server

Example request:
curl --request PUT \
    "/api/admin/email-servers/7" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"est\",
    \"type\": \"sapiente\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/email-servers/7"
);

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

let body = {
    "name": "est",
    "type": "sapiente",
    "connection_config": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/7';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'est',
            'type' => 'sapiente',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/7'
payload = {
    "name": "est",
    "type": "sapiente",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/email-servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Email server ID. Example: 7

Body Parameters

name   string   

Example: est

type   string   

Example: sapiente

connection_config   object   

Delete email server

Example request:
curl --request DELETE \
    "/api/admin/email-servers/18" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/email-servers/18"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/18';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/18'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/email-servers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Email server ID. Example: 18

List remote email domains

Example request:
curl --request GET \
    --get "/api/admin/email-servers/et/sync/domains" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/email-servers/et/sync/domains"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/et/sync/domains';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/et/sync/domains'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/email-servers/{id}/sync/domains

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the email server. Example: et

Import email domain

Example request:
curl --request POST \
    "/api/admin/email-servers/id/sync/import-domain" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"illo\",
    \"service_id\": 11
}"
const url = new URL(
    "/api/admin/email-servers/id/sync/import-domain"
);

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

let body = {
    "name": "illo",
    "service_id": 11
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/email-servers/id/sync/import-domain';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'illo',
            'service_id' => 11,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/email-servers/id/sync/import-domain'
payload = {
    "name": "illo",
    "service_id": 11
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/email-servers/{id}/sync/import-domain

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the email server. Example: id

Body Parameters

name   string   

Example: illo

service_id   integer   

Example: 11

Remote Backups

List remote backup types

Example request:
curl --request GET \
    --get "/api/admin/remote-backups/types" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/remote-backups/types"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/remote-backups/types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/remote-backups/types'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/remote-backups/types

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Test connection

Example request:
curl --request POST \
    "/api/admin/remote-backups/test-connection" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"voluptatem\",
    \"type\": \"qui\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/remote-backups/test-connection"
);

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

let body = {
    "name": "voluptatem",
    "type": "qui",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/remote-backups/test-connection';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'voluptatem',
            'type' => 'qui',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/remote-backups/test-connection'
payload = {
    "name": "voluptatem",
    "type": "qui",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/remote-backups/test-connection

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: voluptatem

type   string   

Example: qui

connection_config   object   

List remote backup connections

Example request:
curl --request GET \
    --get "/api/admin/remote-backups" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/remote-backups"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/remote-backups';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/remote-backups'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/remote-backups

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Add remote backup connection

Example request:
curl --request POST \
    "/api/admin/remote-backups" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"repudiandae\",
    \"type\": \"et\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/remote-backups"
);

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

let body = {
    "name": "repudiandae",
    "type": "et",
    "connection_config": []
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/remote-backups';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'repudiandae',
            'type' => 'et',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/remote-backups'
payload = {
    "name": "repudiandae",
    "type": "et",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/remote-backups

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: repudiandae

type   string   

Example: et

connection_config   object   

Update remote backup connection

Example request:
curl --request PUT \
    "/api/admin/remote-backups/14" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"enim\",
    \"type\": \"dolores\",
    \"connection_config\": []
}"
const url = new URL(
    "/api/admin/remote-backups/14"
);

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

let body = {
    "name": "enim",
    "type": "dolores",
    "connection_config": []
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/remote-backups/14';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'enim',
            'type' => 'dolores',
            'connection_config' => [],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/remote-backups/14'
payload = {
    "name": "enim",
    "type": "dolores",
    "connection_config": []
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/remote-backups/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Remote backup connection ID. Example: 14

Body Parameters

name   string   

Example: enim

type   string   

Example: dolores

connection_config   object   

Delete remote backup connection

Example request:
curl --request DELETE \
    "/api/admin/remote-backups/4" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/remote-backups/4"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/remote-backups/4';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/remote-backups/4'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/remote-backups/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Remote backup connection ID. Example: 4

List backup containers

Example request:
curl --request GET \
    --get "/api/admin/backup-containers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/backup-containers"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/backup-containers';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/backup-containers'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/backup-containers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Create backup container

Example request:
curl --request POST \
    "/api/admin/backup-containers" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"remote_backup_id\": 12,
    \"name\": \"temporibus\",
    \"location\": \"cum\",
    \"is_local_storage\": true,
    \"max_size_backups_per_site\": 12,
    \"max_number_backups_per_site\": 7,
    \"backup_type\": \"full\"
}"
const url = new URL(
    "/api/admin/backup-containers"
);

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

let body = {
    "remote_backup_id": 12,
    "name": "temporibus",
    "location": "cum",
    "is_local_storage": true,
    "max_size_backups_per_site": 12,
    "max_number_backups_per_site": 7,
    "backup_type": "full"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/backup-containers';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'remote_backup_id' => 12,
            'name' => 'temporibus',
            'location' => 'cum',
            'is_local_storage' => true,
            'max_size_backups_per_site' => 12,
            'max_number_backups_per_site' => 7,
            'backup_type' => 'full',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/backup-containers'
payload = {
    "remote_backup_id": 12,
    "name": "temporibus",
    "location": "cum",
    "is_local_storage": true,
    "max_size_backups_per_site": 12,
    "max_number_backups_per_site": 7,
    "backup_type": "full"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/backup-containers

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

remote_backup_id   integer   

Example: 12

name   string   

Example: temporibus

location   string   

Example: cum

is_local_storage   boolean   

Example: true

max_size_backups_per_site   integer   

Example: 12

max_number_backups_per_site   integer   

Example: 7

backup_type   string   

Example: full

Must be one of:
  • full
  • incremental
backup_type_rules   object  optional  
rules   object  optional  

Update backup container

Example request:
curl --request PUT \
    "/api/admin/backup-containers/10" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"remote_backup_id\": 7,
    \"name\": \"delectus\",
    \"location\": \"incidunt\",
    \"is_local_storage\": true,
    \"max_size_backups_per_site\": 15,
    \"max_number_backups_per_site\": 16,
    \"backup_type\": \"incremental\"
}"
const url = new URL(
    "/api/admin/backup-containers/10"
);

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

let body = {
    "remote_backup_id": 7,
    "name": "delectus",
    "location": "incidunt",
    "is_local_storage": true,
    "max_size_backups_per_site": 15,
    "max_number_backups_per_site": 16,
    "backup_type": "incremental"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/backup-containers/10';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'remote_backup_id' => 7,
            'name' => 'delectus',
            'location' => 'incidunt',
            'is_local_storage' => true,
            'max_size_backups_per_site' => 15,
            'max_number_backups_per_site' => 16,
            'backup_type' => 'incremental',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/backup-containers/10'
payload = {
    "remote_backup_id": 7,
    "name": "delectus",
    "location": "incidunt",
    "is_local_storage": true,
    "max_size_backups_per_site": 15,
    "max_number_backups_per_site": 16,
    "backup_type": "incremental"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/backup-containers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Backup container ID. Example: 10

Body Parameters

remote_backup_id   integer   

Example: 7

name   string   

Example: delectus

location   string   

Example: incidunt

is_local_storage   boolean   

Example: true

max_size_backups_per_site   integer   

Example: 15

max_number_backups_per_site   integer   

Example: 16

backup_type   string   

Example: incremental

Must be one of:
  • full
  • incremental
backup_type_rules   object  optional  
rules   object  optional  

Delete backup container ID

Example request:
curl --request DELETE \
    "/api/admin/backup-containers/8" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/backup-containers/8"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/backup-containers/8';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/backup-containers/8'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/backup-containers/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Backup container ID. Example: 8

Update backup container rules

Example request:
curl --request PUT \
    "/api/admin/backup-containers/18/rules" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"*\": {
        \"type\": \"client\",
        \"values\": [
            18
        ]
    }
}"
const url = new URL(
    "/api/admin/backup-containers/18/rules"
);

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

let body = {
    "*": {
        "type": "client",
        "values": [
            18
        ]
    }
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/backup-containers/18/rules';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            '*' => [
                'type' => 'client',
                'values' => [
                    18,
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/backup-containers/18/rules'
payload = {
    "*": {
        "type": "client",
        "values": [
            18
        ]
    }
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/backup-containers/{id}/rules

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Backup container ID. Example: 18

Body Parameters

*   object   
type   string   

Example: client

Must be one of:
  • instance
  • service
  • client
  • plan
  • server
  • server_group
values   integer[]   

List backup logs

Example request:
curl --request GET \
    --get "/api/admin/backup-logs" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"search_term\": \"quo\",
    \"plan_id\": 9,
    \"server_id\": 3,
    \"instance_id\": 6,
    \"container_id\": 12,
    \"remote_backup_id\": 14
}"
const url = new URL(
    "/api/admin/backup-logs"
);

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

let body = {
    "search_term": "quo",
    "plan_id": 9,
    "server_id": 3,
    "instance_id": 6,
    "container_id": 12,
    "remote_backup_id": 14
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/backup-logs';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'search_term' => 'quo',
            'plan_id' => 9,
            'server_id' => 3,
            'instance_id' => 6,
            'container_id' => 12,
            'remote_backup_id' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/backup-logs'
payload = {
    "search_term": "quo",
    "plan_id": 9,
    "server_id": 3,
    "instance_id": 6,
    "container_id": 12,
    "remote_backup_id": 14
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/backup-logs

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

search_term   string  optional  

Example: quo

plan_id   integer  optional  

Example: 9

server_id   integer  optional  

Example: 3

instance_id   integer  optional  

Example: 6

container_id   integer  optional  

Example: 12

remote_backup_id   integer  optional  

Example: 14

Plans

List plans

Example request:
curl --request GET \
    --get "/api/admin/plans" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/plans"
);

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

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

url = '/api/admin/plans'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/plans

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Create plan

Example request:
curl --request POST \
    "/api/admin/plans" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"error\",
    \"application_limit\": 16,
    \"server_type\": \"reiciendis\",
    \"server_group_id\": 6,
    \"server_assign_rule\": \"random\",
    \"server_id\": 10,
    \"remote_suspend\": false,
    \"dns_server_internal\": false,
    \"dns_server_type\": \"sed\",
    \"dns_server_id\": 19,
    \"dns_zone_template_id\": 19,
    \"email_server_internal\": false,
    \"email_server_type\": \"necessitatibus\",
    \"email_server_id\": 5,
    \"scan_interval\": 15,
    \"is_automatic_backups_enabled\": false,
    \"is_automatic_backups_editable\": false,
    \"automatic_backups_frequency\": \"daily\"
}"
const url = new URL(
    "/api/admin/plans"
);

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

let body = {
    "name": "error",
    "application_limit": 16,
    "server_type": "reiciendis",
    "server_group_id": 6,
    "server_assign_rule": "random",
    "server_id": 10,
    "remote_suspend": false,
    "dns_server_internal": false,
    "dns_server_type": "sed",
    "dns_server_id": 19,
    "dns_zone_template_id": 19,
    "email_server_internal": false,
    "email_server_type": "necessitatibus",
    "email_server_id": 5,
    "scan_interval": 15,
    "is_automatic_backups_enabled": false,
    "is_automatic_backups_editable": false,
    "automatic_backups_frequency": "daily"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/plans';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'error',
            'application_limit' => 16,
            'server_type' => 'reiciendis',
            'server_group_id' => 6,
            'server_assign_rule' => 'random',
            'server_id' => 10,
            'remote_suspend' => false,
            'dns_server_internal' => false,
            'dns_server_type' => 'sed',
            'dns_server_id' => 19,
            'dns_zone_template_id' => 19,
            'email_server_internal' => false,
            'email_server_type' => 'necessitatibus',
            'email_server_id' => 5,
            'scan_interval' => 15,
            'is_automatic_backups_enabled' => false,
            'is_automatic_backups_editable' => false,
            'automatic_backups_frequency' => 'daily',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/plans'
payload = {
    "name": "error",
    "application_limit": 16,
    "server_type": "reiciendis",
    "server_group_id": 6,
    "server_assign_rule": "random",
    "server_id": 10,
    "remote_suspend": false,
    "dns_server_internal": false,
    "dns_server_type": "sed",
    "dns_server_id": 19,
    "dns_zone_template_id": 19,
    "email_server_internal": false,
    "email_server_type": "necessitatibus",
    "email_server_id": 5,
    "scan_interval": 15,
    "is_automatic_backups_enabled": false,
    "is_automatic_backups_editable": false,
    "automatic_backups_frequency": "daily"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/plans

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: error

application_limit   integer   

Example: 16

server_type   string   

Example: reiciendis

server_group_id   integer  optional  

Example: 6

server_assign_rule   string  optional  

Example: random

Must be one of:
  • random
  • least_accounts
  • specific_server
server_id   integer  optional  

Example: 10

account_config   object  optional  
remote_suspend   boolean  optional  

Example: false

dns_server_internal   boolean  optional  

Example: false

dns_server_type   string  optional  

Example: sed

dns_server_id   integer  optional  

Example: 19

dns_account_config   object  optional  
dns_zone_template_id   integer  optional  

Example: 19

email_server_internal   boolean  optional  

Example: false

email_server_type   string  optional  

Example: necessitatibus

email_server_id   integer  optional  

Example: 5

email_account_config   object  optional  
config   object  optional  
packages   object  optional  
automatic_install_plugins   object  optional  
automatic_install_themes   object  optional  
blacklist_plugins   object  optional  
delete_blacklisted_plugins   object  optional  
delete_blacklisted_themes   object  optional  
scan_interval   integer  optional  

Example: 15

is_automatic_backups_enabled   boolean  optional  

Example: false

is_automatic_backups_editable   boolean  optional  

Example: false

automatic_backups_frequency   string  optional  

Example: daily

Must be one of:
  • daily
  • weekly
  • monthly

Show plan details

Example request:
curl --request GET \
    --get "/api/admin/plans/7" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/plans/7"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/plans/7';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/plans/7'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/plans/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Plan ID. Example: 7

Update plan

Example request:
curl --request PUT \
    "/api/admin/plans/2" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"doloremque\",
    \"application_limit\": 10,
    \"server_type\": \"nam\",
    \"server_group_id\": 4,
    \"server_assign_rule\": \"random\",
    \"server_id\": 2,
    \"remote_suspend\": false,
    \"dns_server_internal\": true,
    \"dns_server_type\": \"sit\",
    \"dns_server_id\": 15,
    \"dns_zone_template_id\": 10,
    \"email_server_internal\": false,
    \"email_server_type\": \"magni\",
    \"email_server_id\": 9,
    \"scan_interval\": 13,
    \"is_automatic_backups_enabled\": true,
    \"is_automatic_backups_editable\": false,
    \"automatic_backups_frequency\": \"weekly\"
}"
const url = new URL(
    "/api/admin/plans/2"
);

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

let body = {
    "name": "doloremque",
    "application_limit": 10,
    "server_type": "nam",
    "server_group_id": 4,
    "server_assign_rule": "random",
    "server_id": 2,
    "remote_suspend": false,
    "dns_server_internal": true,
    "dns_server_type": "sit",
    "dns_server_id": 15,
    "dns_zone_template_id": 10,
    "email_server_internal": false,
    "email_server_type": "magni",
    "email_server_id": 9,
    "scan_interval": 13,
    "is_automatic_backups_enabled": true,
    "is_automatic_backups_editable": false,
    "automatic_backups_frequency": "weekly"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/plans/2';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'doloremque',
            'application_limit' => 10,
            'server_type' => 'nam',
            'server_group_id' => 4,
            'server_assign_rule' => 'random',
            'server_id' => 2,
            'remote_suspend' => false,
            'dns_server_internal' => true,
            'dns_server_type' => 'sit',
            'dns_server_id' => 15,
            'dns_zone_template_id' => 10,
            'email_server_internal' => false,
            'email_server_type' => 'magni',
            'email_server_id' => 9,
            'scan_interval' => 13,
            'is_automatic_backups_enabled' => true,
            'is_automatic_backups_editable' => false,
            'automatic_backups_frequency' => 'weekly',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/plans/2'
payload = {
    "name": "doloremque",
    "application_limit": 10,
    "server_type": "nam",
    "server_group_id": 4,
    "server_assign_rule": "random",
    "server_id": 2,
    "remote_suspend": false,
    "dns_server_internal": true,
    "dns_server_type": "sit",
    "dns_server_id": 15,
    "dns_zone_template_id": 10,
    "email_server_internal": false,
    "email_server_type": "magni",
    "email_server_id": 9,
    "scan_interval": 13,
    "is_automatic_backups_enabled": true,
    "is_automatic_backups_editable": false,
    "automatic_backups_frequency": "weekly"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/plans/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Plan ID. Example: 2

Body Parameters

name   string   

Example: doloremque

application_limit   integer   

Example: 10

server_type   string   

Example: nam

server_group_id   integer  optional  

Example: 4

server_assign_rule   string  optional  

Example: random

Must be one of:
  • random
  • least_accounts
  • specific_server
server_id   integer  optional  

Example: 2

account_config   object  optional  
remote_suspend   boolean  optional  

Example: false

dns_server_internal   boolean  optional  

Example: true

dns_server_type   string  optional  

Example: sit

dns_server_id   integer  optional  

Example: 15

dns_account_config   object  optional  
dns_zone_template_id   integer  optional  

Example: 10

email_server_internal   boolean  optional  

Example: false

email_server_type   string  optional  

Example: magni

email_server_id   integer  optional  

Example: 9

email_account_config   object  optional  
config   object  optional  
packages   object  optional  
automatic_install_plugins   object  optional  
automatic_install_themes   object  optional  
blacklist_plugins   object  optional  
delete_blacklisted_plugins   object  optional  
delete_blacklisted_themes   object  optional  
scan_interval   integer  optional  

Example: 13

is_automatic_backups_enabled   boolean  optional  

Example: true

is_automatic_backups_editable   boolean  optional  

Example: false

automatic_backups_frequency   string  optional  

Example: weekly

Must be one of:
  • daily
  • weekly
  • monthly

Delete plan

Example request:
curl --request DELETE \
    "/api/admin/plans/11" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/plans/11"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/plans/11';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/plans/11'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/plans/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Plan ID. Example: 11

Instances

List instances

Example request:
curl --request GET \
    --get "/api/admin/instances" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": \"est\",
    \"user_id\": 3,
    \"hosting_account_id\": 7,
    \"plan_id\": 3,
    \"service_id\": 5,
    \"server_id\": 1,
    \"status\": \"nobis\"
}"
const url = new URL(
    "/api/admin/instances"
);

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

let body = {
    "filter": "est",
    "user_id": 3,
    "hosting_account_id": 7,
    "plan_id": 3,
    "service_id": 5,
    "server_id": 1,
    "status": "nobis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => 'est',
            'user_id' => 3,
            'hosting_account_id' => 7,
            'plan_id' => 3,
            'service_id' => 5,
            'server_id' => 1,
            'status' => 'nobis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances'
payload = {
    "filter": "est",
    "user_id": 3,
    "hosting_account_id": 7,
    "plan_id": 3,
    "service_id": 5,
    "server_id": 1,
    "status": "nobis"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

filter   string  optional  

Example: est

user_id   integer  optional  

Example: 3

hosting_account_id   integer  optional  

Example: 7

plan_id   integer  optional  

Example: 3

service_id   integer  optional  

Example: 5

server_id   integer  optional  

Example: 1

status   string  optional  

Example: nobis

List failed instances

Example request:
curl --request GET \
    --get "/api/admin/instances/failed" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": \"voluptatem\",
    \"hosting_account_id\": 18,
    \"plan_id\": 20,
    \"service_id\": 20,
    \"server_id\": 17
}"
const url = new URL(
    "/api/admin/instances/failed"
);

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

let body = {
    "filter": "voluptatem",
    "hosting_account_id": 18,
    "plan_id": 20,
    "service_id": 20,
    "server_id": 17
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/failed';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => 'voluptatem',
            'hosting_account_id' => 18,
            'plan_id' => 20,
            'service_id' => 20,
            'server_id' => 17,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/failed'
payload = {
    "filter": "voluptatem",
    "hosting_account_id": 18,
    "plan_id": 20,
    "service_id": 20,
    "server_id": 17
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/failed

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

filter   string  optional  

Example: voluptatem

hosting_account_id   integer  optional  

Example: 18

plan_id   integer  optional  

Example: 20

service_id   integer  optional  

Example: 20

server_id   integer  optional  

Example: 17

Show failed instance details

Example request:
curl --request GET \
    --get "/api/admin/instances/failed/6" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/failed/6"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/failed/6';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/failed/6'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/failed/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 6

Delete failed instance

Example request:
curl --request DELETE \
    "/api/admin/instances/failed/6" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/failed/6"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/failed/6';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/failed/6'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/instances/failed/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 6

Retry install failed instance

Example request:
curl --request PUT \
    "/api/admin/instances/failed/14/retry" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/failed/14/retry"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/failed/14/retry';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/failed/14/retry'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/instances/failed/{id}/retry

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 14

List archived instances

Example request:
curl --request GET \
    --get "/api/admin/instances/archived" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": \"suscipit\",
    \"user_id\": 18,
    \"hosting_account_id\": 15,
    \"plan_id\": 4,
    \"service_id\": 5,
    \"server_id\": 5
}"
const url = new URL(
    "/api/admin/instances/archived"
);

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

let body = {
    "filter": "suscipit",
    "user_id": 18,
    "hosting_account_id": 15,
    "plan_id": 4,
    "service_id": 5,
    "server_id": 5
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/archived';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => 'suscipit',
            'user_id' => 18,
            'hosting_account_id' => 15,
            'plan_id' => 4,
            'service_id' => 5,
            'server_id' => 5,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/archived'
payload = {
    "filter": "suscipit",
    "user_id": 18,
    "hosting_account_id": 15,
    "plan_id": 4,
    "service_id": 5,
    "server_id": 5
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/archived

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

filter   string  optional  

Example: suscipit

user_id   integer  optional  

Example: 18

hosting_account_id   integer  optional  

Example: 15

plan_id   integer  optional  

Example: 4

service_id   integer  optional  

Example: 5

server_id   integer  optional  

Example: 5

Show archived instance details

Example request:
curl --request GET \
    --get "/api/admin/instances/archived/18" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/archived/18"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/archived/18';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/archived/18'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/archived/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 18

Delete archived instance

Example request:
curl --request DELETE \
    "/api/admin/instances/archived/10/delete" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/archived/10/delete"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/archived/10/delete';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/archived/10/delete'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/instances/archived/{id}/delete

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 10

Show instance details

Example request:
curl --request GET \
    --get "/api/admin/instances/8" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/8"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/8';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/8'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 8

Delete instance

Example request:
curl --request DELETE \
    "/api/admin/instances/3" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"remove_data\": true,
    \"remove_database\": true
}"
const url = new URL(
    "/api/admin/instances/3"
);

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

let body = {
    "remove_data": true,
    "remove_database": true
};

fetch(url, {
    method: "DELETE",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/3';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'remove_data' => true,
            'remove_database' => true,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/3'
payload = {
    "remove_data": true,
    "remove_database": true
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/instances/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 3

Body Parameters

remove_data   boolean  optional  

Example: true

remove_database   boolean  optional  

Example: true

Get installed SSL certificate

Example request:
curl --request GET \
    --get "/api/admin/instances/5/installed-ssl-cert" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/5/installed-ssl-cert"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/5/installed-ssl-cert';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/5/installed-ssl-cert'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/{id}/installed-ssl-cert

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 5

List WordPress users

Example request:
curl --request GET \
    --get "/api/admin/instances/12/wordpress/users" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/instances/12/wordpress/users"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/12/wordpress/users';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/12/wordpress/users'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/instances/{id}/wordpress/users

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 12

Create WordPress SSO URL

Example request:
curl --request POST \
    "/api/admin/instances/9/wordpress/sso-url" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"user\": 14
}"
const url = new URL(
    "/api/admin/instances/9/wordpress/sso-url"
);

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

let body = {
    "user": 14
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/instances/9/wordpress/sso-url';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'user' => 14,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/instances/9/wordpress/sso-url'
payload = {
    "user": 14
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/instances/{id}/wordpress/sso-url

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Instance ID. Example: 9

Body Parameters

user   integer   

Example: 14

Services

List services

Example request:
curl --request GET \
    --get "/api/admin/services" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"search_term\": \"eius\",
    \"user_id\": 6,
    \"plan_id\": 3,
    \"archived\": false
}"
const url = new URL(
    "/api/admin/services"
);

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

let body = {
    "search_term": "eius",
    "user_id": 6,
    "plan_id": 3,
    "archived": false
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/services';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'search_term' => 'eius',
            'user_id' => 6,
            'plan_id' => 3,
            'archived' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/services'
payload = {
    "search_term": "eius",
    "user_id": 6,
    "plan_id": 3,
    "archived": false
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/services

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

search_term   string  optional  

Example: eius

user_id   integer  optional  

Example: 6

plan_id   integer  optional  

Example: 3

archived   boolean  optional  

Example: false

List archived services

Example request:
curl --request GET \
    --get "/api/admin/services/archived" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"search_term\": \"quibusdam\",
    \"user_id\": 17
}"
const url = new URL(
    "/api/admin/services/archived"
);

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

let body = {
    "search_term": "quibusdam",
    "user_id": 17
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/services/archived';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'search_term' => 'quibusdam',
            'user_id' => 17,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/services/archived'
payload = {
    "search_term": "quibusdam",
    "user_id": 17
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/services/archived

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

search_term   string  optional  

Example: quibusdam

user_id   integer  optional  

Example: 17

Show service details

Example request:
curl --request GET \
    --get "/api/admin/services/16" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/services/16"
);

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

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

url = '/api/admin/services/16'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/services/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Service ID. Example: 16

Show archived service details

Example request:
curl --request GET \
    --get "/api/admin/services/4/archived" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/services/4/archived"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/services/4/archived';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/services/4/archived'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/services/{id}/archived

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Service ID. Example: 4

Add package to service

Example request:
curl --request POST \
    "/api/admin/service/20/package" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"package_id\": 8
}"
const url = new URL(
    "/api/admin/service/20/package"
);

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

let body = {
    "package_id": 8
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/service/20/package';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'package_id' => 8,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/service/20/package'
payload = {
    "package_id": 8
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/service/{id}/package

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Service ID. Example: 20

Body Parameters

package_id   integer   

Example: 8

Delete package from service

Example request:
curl --request DELETE \
    "/api/admin/service/18/package/culpa" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/service/18/package/culpa"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/service/18/package/culpa';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/service/18/package/culpa'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/service/{id}/package/{packageId}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Service ID. Example: 18

packageId   string   

Example: culpa

Delete service

Example request:
curl --request DELETE \
    "/api/admin/services/1" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/services/1"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/services/1';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/services/1'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/services/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Service ID. Example: 1

Delete archived service

Example request:
curl --request DELETE \
    "/api/admin/services/16/delete" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/services/16/delete"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/services/16/delete';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/services/16/delete'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/services/{id}/delete

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Service ID. Example: 16

Hosting Accounts

Show hosting account details

Example request:
curl --request GET \
    --get "/api/admin/hosting-accounts/3" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/hosting-accounts/3"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/hosting-accounts/3';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/hosting-accounts/3'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/hosting-accounts/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Hosting Account ID. Example: 3

List hosting account domains

Example request:
curl --request GET \
    --get "/api/admin/hosting-accounts/17/domains" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/hosting-accounts/17/domains"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/hosting-accounts/17/domains';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/hosting-accounts/17/domains'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/hosting-accounts/{id}/domains

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Hosting Account ID. Example: 17

List hosting account SSL domains

Example request:
curl --request GET \
    --get "/api/admin/hosting-accounts/3/ssl-domains" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/hosting-accounts/3/ssl-domains"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/hosting-accounts/3/ssl-domains';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/hosting-accounts/3/ssl-domains'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/hosting-accounts/{id}/ssl-domains

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Hosting Account ID. Example: 3

Show hosting account usage

Example request:
curl --request GET \
    --get "/api/admin/hosting-accounts/20/usage" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/hosting-accounts/20/usage"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/hosting-accounts/20/usage';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/hosting-accounts/20/usage'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/hosting-accounts/{id}/usage

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Hosting Account ID. Example: 20

Reinstall hosting account

Example request:
curl --request PUT \
    "/api/admin/hosting-accounts/10/reinstall" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/hosting-accounts/10/reinstall"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/hosting-accounts/10/reinstall';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/hosting-accounts/10/reinstall'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/hosting-accounts/{id}/reinstall

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Hosting Account ID. Example: 10

Notifications

Get list of notification templates assigned to recipient

Example request:
curl --request GET \
    --get "/api/admin/notification-templates/delectus" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"filter\": \"nostrum\"
}"
const url = new URL(
    "/api/admin/notification-templates/delectus"
);

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

let body = {
    "filter": "nostrum"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-templates/delectus';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'filter' => 'nostrum',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-templates/delectus'
payload = {
    "filter": "nostrum"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/notification-templates/{recipient}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

recipient   string   

Example: delectus

Body Parameters

filter   string  optional  

Example: nostrum

Get single notification template to edit

Example request:
curl --request GET \
    --get "/api/admin/notification-template/eius" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notification-template/eius"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-template/eius';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-template/eius'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/notification-template/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the notification template. Example: eius

Update notification template

Example request:
curl --request PUT \
    "/api/admin/notification-template/id/update" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"messages\": [
        {
            \"message\": \"ducimus\",
            \"subject\": \"adipisci\"
        }
    ]
}"
const url = new URL(
    "/api/admin/notification-template/id/update"
);

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

let body = {
    "messages": [
        {
            "message": "ducimus",
            "subject": "adipisci"
        }
    ]
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-template/id/update';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'messages' => [
                [
                    'message' => 'ducimus',
                    'subject' => 'adipisci',
                ],
            ],
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-template/id/update'
payload = {
    "messages": [
        {
            "message": "ducimus",
            "subject": "adipisci"
        }
    ]
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/notification-template/{id}/update

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the notification template. Example: id

Body Parameters

messages   object[]  optional  
message   string  optional  

Example: ducimus

subject   string  optional  

Example: adipisci

Show preview of email

Example request:
curl --request POST \
    "/api/admin/notification-template/preview" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notification-template/preview"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-template/preview';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-template/preview'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/notification-template/preview

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Send test email

Example request:
curl --request GET \
    --get "/api/admin/notification-template/fugiat/test" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notification-template/fugiat/test"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-template/fugiat/test';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-template/fugiat/test'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/notification-template/{id}/test

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the notification template. Example: fugiat

Change notification template status

Example request:
curl --request PUT \
    "/api/admin/notification-template/maiores/status" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"enabled\": false
}"
const url = new URL(
    "/api/admin/notification-template/maiores/status"
);

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

let body = {
    "enabled": false
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-template/maiores/status';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'enabled' => false,
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-template/maiores/status'
payload = {
    "enabled": false
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/notification-template/{id}/status

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the notification template. Example: maiores

Body Parameters

enabled   boolean   

Example: false

Restore notification message to default

Example request:
curl --request POST \
    "/api/admin/notification-template/corrupti/restore" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notification-template/corrupti/restore"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notification-template/corrupti/restore';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notification-template/corrupti/restore'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/notification-template/{id}/restore

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   string   

The ID of the notification template. Example: corrupti

Show email settings

Example request:
curl --request GET \
    --get "/api/admin/notifications/settings" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notifications/settings"
);

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

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

url = '/api/admin/notifications/settings'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/notifications/settings

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Update email settings

Example request:
curl --request PUT \
    "/api/admin/notifications/settings" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notifications/settings"
);

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

fetch(url, {
    method: "PUT",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notifications/settings';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notifications/settings'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/notifications/settings

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Test connection

Example request:
curl --request POST \
    "/api/admin/notifications/test-connection" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/notifications/test-connection"
);

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

fetch(url, {
    method: "POST",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/notifications/test-connection';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/notifications/test-connection'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/notifications/test-connection

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Admin Groups

List admin group types

Example request:
curl --request GET \
    --get "/api/admin/admin-groups/types" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admin-groups/types"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admin-groups/types';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admin-groups/types'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/admin-groups/types

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List admin groups

Example request:
curl --request GET \
    --get "/api/admin/admin-groups" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admin-groups"
);

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

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

url = '/api/admin/admin-groups'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/admin-groups

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

List admin group permissions and notifications

Example request:
curl --request GET \
    --get "/api/admin/admin-groups/permissions" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admin-groups/permissions"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admin-groups/permissions';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admin-groups/permissions'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/admin-groups/permissions

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Show admin group details

Example request:
curl --request GET \
    --get "/api/admin/admin-groups/8" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admin-groups/8"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admin-groups/8';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admin-groups/8'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/admin-groups/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin Group ID. Example: 8

Create admin group

Example request:
curl --request POST \
    "/api/admin/admin-group" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"accusantium\"
}"
const url = new URL(
    "/api/admin/admin-group"
);

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

let body = {
    "name": "accusantium"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admin-group';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'accusantium',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admin-group'
payload = {
    "name": "accusantium"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/admin-group

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: accusantium

permissions   object  optional  
notifications   object  optional  

Update admin group

Example request:
curl --request PUT \
    "/api/admin/admin-group/10" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"natus\"
}"
const url = new URL(
    "/api/admin/admin-group/10"
);

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

let body = {
    "name": "natus"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admin-group/10';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'natus',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admin-group/10'
payload = {
    "name": "natus"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/admin-group/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin Group ID. Example: 10

Body Parameters

name   string   

Example: natus

permissions   object  optional  
notifications   object  optional  

Delete admin group

Example request:
curl --request DELETE \
    "/api/admin/admin-group/18" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/admin-group/18"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/admin-group/18';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/admin-group/18'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/admin-group/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Admin Group ID. Example: 18

Tasks

List tasks

Example request:
curl --request GET \
    --get "/api/admin/tasks" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"search_term\": \"ea\",
    \"date_range\": \"quo\",
    \"filter_types\": \"esse\",
    \"filter_statuses\": \"nobis\"
}"
const url = new URL(
    "/api/admin/tasks"
);

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

let body = {
    "search_term": "ea",
    "date_range": "quo",
    "filter_types": "esse",
    "filter_statuses": "nobis"
};

fetch(url, {
    method: "GET",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/tasks';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'search_term' => 'ea',
            'date_range' => 'quo',
            'filter_types' => 'esse',
            'filter_statuses' => 'nobis',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/tasks'
payload = {
    "search_term": "ea",
    "date_range": "quo",
    "filter_types": "esse",
    "filter_statuses": "nobis"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Example response (401):

Show headers
cache-control: no-cache, private
content-type: application/json
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/tasks

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

search_term   string  optional  

Example: ea

date_range   string  optional  

Example: quo

filter_types   string  optional  

Example: esse

filter_statuses   string  optional  

Example: nobis

List running tasks

Example request:
curl --request GET \
    --get "/api/admin/tasks/running" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/tasks/running"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/tasks/running';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/tasks/running'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/tasks/running

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Cancel task

Example request:
curl --request DELETE \
    "/api/admin/tasks/18/cancel" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/tasks/18/cancel"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/tasks/18/cancel';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/tasks/18/cancel'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/tasks/{id}/cancel

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Task ID. Example: 18

Check worker status

Example request:
curl --request GET \
    --get "/api/admin/tasks/worker-status" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/tasks/worker-status"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/tasks/worker-status';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/tasks/worker-status'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/tasks/worker-status

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Check task status

Example request:
curl --request GET \
    --get "/api/admin/tasks/19/status" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/tasks/19/status"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/tasks/19/status';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/tasks/19/status'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/tasks/{id}/status

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Task ID. Example: 19

Retry task

Example request:
curl --request GET \
    --get "/api/admin/tasks/18/retry" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/tasks/18/retry"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/tasks/18/retry';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/tasks/18/retry'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/tasks/{id}/retry

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Task ID. Example: 18

WordPress Plugins and Themes

List theme categories

Example request:
curl --request GET \
    --get "/api/admin/theme-categories" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/theme-categories"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/theme-categories';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/theme-categories'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/theme-categories

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Create theme category

Example request:
curl --request POST \
    "/api/admin/theme-category" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"illo\"
}"
const url = new URL(
    "/api/admin/theme-category"
);

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

let body = {
    "name": "illo"
};

fetch(url, {
    method: "POST",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/theme-category';
$response = $client->post(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'illo',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/theme-category'
payload = {
    "name": "illo"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

POST api/admin/theme-category

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

Body Parameters

name   string   

Example: illo

Delete theme category

Example request:
curl --request DELETE \
    "/api/admin/theme-category/6" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/theme-category/6"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/theme-category/6';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/theme-category/6'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/theme-category/{id}

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Category ID. Example: 6

List themes from category

Example request:
curl --request GET \
    --get "/api/admin/theme-category/20/themes" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/theme-category/20/themes"
);

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

fetch(url, {
    method: "GET",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/theme-category/20/themes';
$response = $client->get(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/theme-category/20/themes'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': '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
vary: Origin
 

{
    "message": "Unauthenticated."
}
 

Request   

GET api/admin/theme-category/{id}/themes

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Category ID. Example: 20

Update theme category

Example request:
curl --request PUT \
    "/api/admin/theme-category/2/update" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json" \
    --data "{
    \"name\": \"soluta\"
}"
const url = new URL(
    "/api/admin/theme-category/2/update"
);

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

let body = {
    "name": "soluta"
};

fetch(url, {
    method: "PUT",
    headers,
    body: JSON.stringify(body),
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/theme-category/2/update';
$response = $client->put(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
        'json' => [
            'name' => 'soluta',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/theme-category/2/update'
payload = {
    "name": "soluta"
}
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

PUT api/admin/theme-category/{id}/update

Headers

Authorization      

Example: Bearer {YOUR_API_TOKEN}

Content-Type      

Example: application/json

URL Parameters

id   integer   

Category ID. Example: 2

Body Parameters

name   string   

Example: soluta

Delete theme from category

Example request:
curl --request DELETE \
    "/api/admin/theme-category/20/delete-theme/odio" \
    --header "Authorization: Bearer {YOUR_API_TOKEN}" \
    --header "Content-Type: application/json"
const url = new URL(
    "/api/admin/theme-category/20/delete-theme/odio"
);

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

fetch(url, {
    method: "DELETE",
    headers,
}).then(response => response.json());
$client = new \GuzzleHttp\Client();
$url = '/api/admin/theme-category/20/delete-theme/odio';
$response = $client->delete(
    $url,
    [
        'headers' => [
            'Authorization' => 'Bearer {YOUR_API_TOKEN}',
            'Content-Type' => 'application/json',
        ],
    ]
);
$body = $response->getBody();
print_r(json_decode((string) $body));
import requests
import json

url = '/api/admin/theme-category/20/delete-theme/odio'
headers = {
  'Authorization': 'Bearer {YOUR_API_TOKEN}',
  'Content-Type': 'application/json'
}

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

Request   

DELETE api/admin/theme-category/{id}/delete-theme/{theme_id}