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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`installToolsRequest`	`object`	body	optional	Install Tools Request
Schema `{ "all": "bool", "run_as": "string", "tools": "map[string]InstallToolsRequestItem" }`

Request examples

      
      /v1/config/tools/install
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`uninstallToolsRequest`	`object`	body	optional	Uninstall Tools Request
Schema `{ "all": "bool", "run_as": "string", "tools": "map[string]UninstallToolsRequestItem", "uninstall_dependencies": "bool" }`

Request examples

      
      /v1/config/tools/uninstall
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`full`	`query`	query	optional	-

Request examples

      
      /health/system
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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

Name	Type	In	Required	Description
`id`	`string`	path	required	Host ID

Request examples

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

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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
            
          

            
              C#
            
          

            
              Go
            
          

      
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"
}

Config endpoints

Gets Parallels Desktop active license

Installs API requires 3rd party tools

Parameters

Uninstalls API requires 3rd party tools

Parameters

Restarts the API Service

Gets the Hardware Info

Gets the API System Health

Parameters

Gets the system logs from the disk

Streams the system logs via WebSocket

Gets the orchestrator host system logs from the disk

Parameters

Streams the system logs via WebSocket

Gets the API Health Probe

Cookie Consent