Get Started

Config

All
Api Keys
Authorization
Catalogs
Claims
Config
Machines
Orchestrator
Packer Templates
ReverseProxy
Roles
Users

Config endpoints

This document contains the endpoints for the Config category.

Gets Parallels Desktop active license:

/api/v1/parallels_desktop/key Authorized

This endpoint returns Parallels Desktop active license

Request examples
/v1/parallels_desktop/key Authorized 
curl --location 'http://localhost/api/v1/parallels_desktop/key' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/parallels_desktop/key");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/parallels_desktop/key"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "advanced_restrictions": "string",
  "cpu_total": "int64",
  "deferred_activation": "string",
  "edition": "string",
  "expiration": "string",
  "grace_period_ends_at": "string",
  "is_volume": "string",
  "main_period_ends_at": "string",
  "max_memory": "int64",
  "serial": "string",
  "status": "string",
  "uuid": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Installs API requires 3rd party tools:

/api/v1/config/tools/install Authorized

This endpoint installs API requires 3rd party tools

Parameters
installToolsRequest Install Tools Request body 
{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}
Request examples
/v1/config/tools/install Authorized 
curl --location 'http://localhost/api/v1/config/tools/install' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/config/tools/install");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/tools/install"
  method := "post"
  payload := strings.NewReader(`{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]InstallToolsRequestItem"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "installed_tools": "map[string]InstallToolsResponseItem",
  "success": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Uninstalls API requires 3rd party tools:

/api/v1/config/tools/uninstall Authorized

This endpoint uninstalls API requires 3rd party tools

Parameters
uninstallToolsRequest Uninstall Tools Request body 
{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}
Request examples
/v1/config/tools/uninstall Authorized 
curl --location 'http://localhost/api/v1/config/tools/uninstall' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/config/tools/uninstall");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}");
request.Content = content;
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/tools/uninstall"
  method := "post"
  payload := strings.NewReader(`{
  "all": "bool",
  "run_as": "string",
  "tools": "map[string]UninstallToolsRequestItem",
  "uninstall_dependencies": "bool"
}`)
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "installed_tools": "map[string]InstallToolsResponseItem",
  "success": "bool"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts the API Service:

/api/v1/config/tools/restart Authorized

This endpoint restarts the API Service

Request examples
/v1/config/tools/restart Authorized 
curl --location 'http://localhost/api/v1/config/tools/restart' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/config/tools/restart");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/tools/restart"
  method := "post"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the Hardware Info:

/api/v1/config/hardware Authorized

This endpoint returns the Hardware Info

Request examples
/v1/config/hardware Authorized 
curl --location 'http://localhost/api/v1/config/hardware' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/config/hardware");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/config/hardware"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "cpu_brand": "string",
  "cpu_type": "string",
  "devops_version": "string",
  "external_ip_address": "string",
  "is_log_streaming_enabled": "bool",
  "is_reverse_proxy_enabled": "bool",
  "os_name": "string",
  "os_version": "string",
  "parallels_desktop_licensed": "bool",
  "parallels_desktop_version": "string",
  "reverse_proxy": "*SystemReverseProxy",
  "system_reserved": "*SystemUsageItem",
  "total": "*SystemUsageItem",
  "total_available": "*SystemUsageItem",
  "total_in_use": "*SystemUsageItem",
  "total_reserved": "*SystemUsageItem"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the API System Health:

/api/health/system Authorized

This endpoint returns the API Health Probe

Parameters
full query
Request examples
/health/system Authorized 
curl --location 'http://localhost/api/health/system' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/health/system");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/health/system"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Gets the system logs from the disk:

/api/logs Authorized

This endpoint returns the system logs from the disk

Request examples
/logs Authorized 
curl --location 'http://localhost/api/logs' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/logs");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/logs"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Streams the system logs via WebSocket:

/api/logs/stream Authorized

This endpoint streams the system logs in real-time via WebSocket

Request examples
/logs/stream Authorized 
curl --location 'http://localhost/api/logs/stream' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/logs/stream");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/logs/stream"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets the orchestrator host system logs from the disk:

/api/v1/orchestrator/hosts/{id}/logs Authorized

This endpoint returns the orchestrator host system logs from the disk

Parameters
id Host ID required path
Request examples
/v1/orchestrator/hosts/{id}/logs Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/logs' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/logs");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/v1/orchestrator/hosts/{id}/logs"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Streams the system logs via WebSocket:

/api/logs/stream Authorized

This endpoint streams the system logs in real-time via WebSocket

Request examples
/logs/stream Authorized 
curl --location 'http://localhost/api/logs/stream' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/logs/stream");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/logs/stream"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Gets the API Health Probe:

/api/health/probe Authorized

This endpoint returns the API Health Probe

Request examples
/health/probe Authorized 
curl --location 'http://localhost/api/health/probe' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/health/probe");
request.Headers.Add("Authorization", "••••••");
var response = await client.SendAsync(request);
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();


package main

import (
  "fmt"
  "net/http"
  "strings"
  "io"
)

func main() {
  url := "http://localhost/api/health/probe"
  method := "get"
  client := &http.Client{}
  req, err := http.NewRequest(method, url, payload)
  if err != nil {
    fmt.Println(err)
    return
  }
  req.Header.Add("Content-Type", "application/json")

  req.Header.Add("Authorization", "••••••")
  res, err := client.Do(req)
  if err != nil {
    fmt.Println(err)
    return
  }
  defer res.Body.Close()
  body, err := io.ReadAll(res.Body)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Println(string(body))
}
Responses 
{
  "additionalProp1": "string",
  "additionalProp2": "string",
  "additionalProp3": "string"
}

{
  "code": "int",
  "message": "string",
  "stack": [
    {
      "code": "int",
      "description": "string",
      "error": "string",
      "path": "string"
    }
  ]
}

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}