Get Started

Orchestrator

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

Orchestrator endpoints

This document contains the endpoints for the Orchestrator category.

Gets all hosts from the orchestrator:

/api/v1/orchestrator/hosts Authorized

This endpoint returns all hosts from the orchestrator

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts");
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"
  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 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a host from the orchestrator:

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

This endpoint returns a host from the orchestrator

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}");
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}"
  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 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets a host hardware info from the orchestrator:

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

This endpoint returns a host hardware info from the orchestrator

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/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/orchestrator/hosts/{id}/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"
}
Register a Host in the orchestrator:

/api/v1/orchestrator/hosts Authorized

This endpoint register a host in the orchestrator

Parameters
hostRequest Host Request body 
{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}
Request examples
/v1/orchestrator/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}");
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/orchestrator/hosts"
  method := "post"
  payload := strings.NewReader(`{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "required_claims": "[]string",
  "required_roles": "[]string",
  "schema": "string",
  "tags": "[]string"
}`)
  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 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Unregister a host from the orchestrator:

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

This endpoint unregister a host from the orchestrator

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}");
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}"
  method := "delete"
  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"
}
Enable a host in the orchestrator:

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

This endpoint will enable an existing host in the orchestrator

Request examples
/v1/orchestrator/hosts/{id}/enable Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/enable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/enable");
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}/enable"
  method := "put"
  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 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Disable a host in the orchestrator:

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

This endpoint will disable an existing host in the orchestrator

Request examples
/v1/orchestrator/hosts/{id}/disable Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/disable' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/disable");
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}/disable"
  method := "put"
  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 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Update a Host in the orchestrator:

/api/v1/orchestrator/hosts Authorized

This endpoint updates a host in the orchestrator

Parameters
hostRequest Host Update Request body 
{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}
Request examples
/v1/orchestrator/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}");
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/orchestrator/hosts"
  method := "put"
  payload := strings.NewReader(`{
  "authentication": "*OrchestratorAuthentication",
  "description": "string",
  "host": "string",
  "port": "string",
  "prefix": "string",
  "schema": "string"
}`)
  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 
[
  {
    "architecture": "string",
    "cpu_model": "string",
    "description": "string",
    "detailed_resources": "*HostResources",
    "devops_version": "string",
    "enabled": "bool",
    "external_ip_address": "string",
    "host": "string",
    "id": "string",
    "is_reverse_proxy_enabled": "bool",
    "os_name": "string",
    "os_version": "string",
    "parallels_desktop_licensed": "bool",
    "parallels_desktop_version": "string",
    "required_claims": "[]string",
    "required_roles": "[]string",
    "resources": {
      "disk_size": "float64",
      "free_disk_size": "float64",
      "logical_cpu_count": "int64",
      "memory_size": "float64",
      "physical_cpu_count": "int64",
      "total_apple_vms": "int64"
    },
    "reverse_proxy": "*HostReverseProxy",
    "reverse_proxy_hosts": "[]*ReverseProxyHost",
    "state": "string",
    "tags": "[]string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator resource overview:

/api/v1/orchestrator/overview/resources Authorized

This endpoint returns orchestrator resource overview

Request examples
/v1/orchestrator/overview/resources Authorized 
curl --location 'http://localhost/api/v1/orchestrator/overview/resources' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/overview/resources");
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/overview/resources"
  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",
  "system_reserved": "HostResourceItem",
  "total": "HostResourceItem",
  "total_available": "HostResourceItem",
  "total_in_use": "HostResourceItem",
  "total_reserved": "HostResourceItem"
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host resources:

/api/v1/orchestrator/overview/{id}/resources Authorized

This endpoint returns orchestrator host resources

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/overview/{id}/resources");
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/overview/{id}/resources"
  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",
  "system_reserved": "HostResourceItem",
  "total": "HostResourceItem",
  "total_available": "HostResourceItem",
  "total_in_use": "HostResourceItem",
  "total_reserved": "HostResourceItem"
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator Virtual Machines:

/api/v1/orchestrator/machines Authorized

This endpoint returns orchestrator Virtual Machines

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines");
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/machines"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator Virtual Machine:

/api/v1/orchestrator/machines/{id} Authorized

This endpoint returns orchestrator Virtual Machine by its ID

Request examples
/v1/orchestrator/machines/{id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{id}");
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/machines/{id}"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes orchestrator virtual machine:

/api/v1/orchestrator/machines/{id} Authorized

This endpoint deletes orchestrator virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/machines/{id}");
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/machines/{id}"
  method := "delete"
  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"
}
Get orchestrator virtual machine status:

/api/v1/orchestrator/machines/{vmId}/status Authorized

This endpoint returns orchestrator virtual machine status

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/status Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/status' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/machines/{vmId}/status");
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/machines/{vmId}/status"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Renames orchestrator virtual machine:

/api/v1/orchestrator/machines/{id}/rename Authorized

This endpoint renames orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{id}/rename Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{id}/rename' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{id}/rename");
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/machines/{id}/rename"
  method := "put"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Configures orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/set Authorized

This endpoint configures orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/set Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/set' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/set");
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/machines/{vmId}/set"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/start Authorized

This endpoint starts orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/start Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/start' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/start");
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/machines/{vmId}/start"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Stops orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/stop Authorized

This endpoint sops orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/stop Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/stop' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/stop");
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/machines/{vmId}/stop"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Executes a command in a orchestrator virtual machine:

/api/v1/orchestrator/machines/{vmId}/execute Authorized

This endpoint executes a command in a orchestrator virtual machine

Parameters
id Virtual Machine ID required path
Request examples
/v1/orchestrator/machines/{vmId}/execute Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines/{vmId}/execute' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/machines/{vmId}/execute");
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/machines/{vmId}/execute"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host virtual machines:

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

This endpoint returns orchestrator host virtual machines

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines");
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}/machines"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Get orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized

This endpoint returns orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}");
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}/machines/{vmId}"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId} Authorized

This endpoint deletes orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}");
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}/machines/{vmId}"
  method := "delete"
  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"
}
Get orchestrator host virtual machine status:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status Authorized

This endpoint returns orchestrator host virtual machine status

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/status");
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}/machines/{vmId}/status"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Renames orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename Authorized

This endpoint renames orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/rename");
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}/machines/{vmId}/rename"
  method := "put"
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Configures orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set Authorized

This endpoint configures orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/set");
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}/machines/{vmId}/set"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start Authorized

This endpoint starts orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/start");
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}/machines/{vmId}/start"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Starts orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop Authorized

This endpoint starts orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/stop");
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}/machines/{vmId}/stop"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Executes a command in a orchestrator host virtual machine:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute Authorized

This endpoint executes a command in a orchestrator host virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/execute");
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}/machines/{vmId}/execute"
  method := "put"
  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 
{
  "operations": [
    {
      "error": "string",
      "group": "string",
      "operation": "string",
      "status": "string"
    }
  ]
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Register a virtual machine in a orchestrator host:

/api/v1/orchestrator/hosts/{id}/machines/register Authorized

This endpoint registers a virtual machine in a orchestrator host

Parameters
id Host ID required path
request Register Virtual Machine Request body 
{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}
Request examples
/v1/orchestrator/hosts/{id}/machines/register Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/register' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/register");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}");
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/orchestrator/hosts/{id}/machines/register"
  method := "post"
  payload := strings.NewReader(`{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}`)
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Unregister a virtual machine in a orchestrator host:

/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister Authorized

This endpoint unregister a virtual machine in a orchestrator host

Parameters
id Host ID required path vmId Virtual Machine ID required path
request Register Virtual Machine Request body 
{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}
Request examples
/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines/{vmId}/unregister");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}");
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/orchestrator/hosts/{id}/machines/{vmId}/unregister"
  method := "post"
  payload := strings.NewReader(`{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}`)
  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": {
      "Public SSH keys synchronization": "string",
      "Rosetta Linux": "string",
      "Share host location": "string",
      "Show developer tools": "string",
      "Swipe from edges": "string",
      "VM hostname synchronization": "string"
    },
    "Allow select boot device": "string",
    "BIOS type": "string",
    "Boot order": "string",
    "Coherence": {
      "Auto-switch to full screen": "string",
      "Disable aero": "string",
      "Hide minimized windows": "string",
      "Show Windows systray in Mac menu": "string"
    },
    "Description": "string",
    "EFI Secure boot": "string",
    "Expiration": {
      "enabled": "bool"
    },
    "External boot device": "string",
    "Fullscreen": {
      "Activate spaces on click": "string",
      "Gamma control": "string",
      "Optimize for games": "string",
      "Scale view mode": "string",
      "Use all displays": "string"
    },
    "Guest Shared Folders": {
      "Automount": "string",
      "enabled": "bool"
    },
    "GuestTools": {
      "state": "string",
      "version": "string"
    },
    "Hardware": {
      "cdrom0": {
        "enabled": "bool",
        "image": "string",
        "port": "string",
        "state": "string"
      },
      "cpu": {
        "VT-x": "bool",
        "accl": "string",
        "auto": "string",
        "cpus": "int64",
        "hotplug": "bool",
        "mode": "string",
        "type": "string"
      },
      "hdd0": {
        "enabled": "bool",
        "image": "string",
        "online-compact": "string",
        "port": "string",
        "size": "string",
        "type": "string"
      },
      "memory": {
        "auto": "string",
        "hotplug": "bool",
        "size": "string"
      },
      "memory_quota": {
        "auto": "string"
      },
      "net0": {
        "card": "string",
        "enabled": "bool",
        "mac": "string",
        "type": "string"
      },
      "sound0": {
        "enabled": "bool",
        "mixer": "string",
        "output": "string"
      },
      "usb": {
        "enabled": "bool"
      },
      "video": {
        "3d-acceleration": "string",
        "adapter-type": "string",
        "automatic-video-memory": "string",
        "high-resolution": "string",
        "high-resolution-in-guest": "string",
        "native-scaling-in-guest": "string",
        "size": "string",
        "vertical-sync": "string"
      }
    },
    "Home": "string",
    "Home path": "string",
    "Host Shared Folders": "map[string]unknown",
    "Host defined sharing": "string",
    "ID": "string",
    "Miscellaneous Sharing": {
      "Shared clipboard": "string",
      "Shared cloud": "string"
    },
    "Modality": {
      "Capture mouse clicks": "string",
      "Opacity (percentage)": "int64",
      "Show on all spaces ": "string",
      "Stay on top": "string"
    },
    "Mouse and Keyboard": {
      "Keyboard optimization mode": "string",
      "Smart mouse optimized for games": "string",
      "Smooth scrolling": "string",
      "Sticky mouse": "string"
    },
    "Name": "string",
    "Network": {
      "Conditioned": "string",
      "Inbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "Outbound": {
        "Bandwidth": "string",
        "Delay": "string",
        "Packet Loss": "string"
      },
      "ipAddresses": [
        {
          "ip": "string",
          "type": "string"
        }
      ]
    },
    "OS": "string",
    "Optimization": {
      "Adaptive hypervisor": "string",
      "Auto compress virtual disks": "string",
      "Disabled Windows logo": "string",
      "Faster virtual machine": "string",
      "Hypervisor type": "string",
      "Longer battery life": "string",
      "Nested virtualization": "string",
      "PMU virtualization": "string",
      "Resource quota": "string",
      "Show battery status": "string"
    },
    "Print Management": {
      "Show host printer UI": "string",
      "Synchronize default printer": "string",
      "Synchronize with host printers": "string"
    },
    "Restore Image": "string",
    "SMBIOS settings": {
      "BIOS Version": "string",
      "Board Manufacturer": "string",
      "System serial number": "string"
    },
    "Security": {
      "Archived": "string",
      "Configuration is locked": "string",
      "Custom password protection": "string",
      "Encrypted": "string",
      "Packed": "string",
      "Protected": "string",
      "TPM enabled": "string",
      "TPM type": "string"
    },
    "Shared Applications": {
      "Bounce dock icon when app flashes": "string",
      "Guest-to-host apps sharing": "string",
      "Host-to-guest apps sharing": "string",
      "Show guest apps folder in Dock": "string",
      "Show guest notifications": "string",
      "enabled": "bool"
    },
    "Shared Profile": {
      "enabled": "bool"
    },
    "Smart Guard": {
      "enabled": "bool"
    },
    "SmartMount": {
      "CD/DVD drives": "string",
      "Network shares": "string",
      "Removable drives": "string",
      "enabled": "bool"
    },
    "Startup and Shutdown": {
      "Autostart": "string",
      "Autostart delay": "int64",
      "Autostop": "string",
      "On shutdown": "string",
      "On window close": "string",
      "Pause idle": "string",
      "Startup view": "string",
      "Undo disks": "string"
    },
    "State": "string",
    "Template": "string",
    "Time Synchronization": {
      "Interval (in seconds)": "int64",
      "Smart mode": "string",
      "Timezone synchronization disabled": "string",
      "enabled": "bool"
    },
    "Travel mode": {
      "Enter condition": "string",
      "Enter threshold": "int64",
      "Quit condition": "string"
    },
    "Type": "string",
    "USB and Bluetooth": {
      "Automatic sharing bluetooth": "string",
      "Automatic sharing cameras": "string",
      "Automatic sharing gamepads": "string",
      "Automatic sharing smart cards": "string",
      "Support USB 3.0": "string"
    },
    "Uptime": "string",
    "host": "string",
    "host_external_ip_address": "string",
    "host_id": "string",
    "host_state": "string",
    "host_url": "string",
    "internal_ip_address": "string",
    "user": "string"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a orchestrator host virtual machine:

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

This endpoint creates a orchestrator host virtual machine

Parameters
id Host ID required path
request Create Virtual Machine Request body 
{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}
Request examples
/v1/orchestrator/hosts/{id}/machines Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}");
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/orchestrator/hosts/{id}/machines"
  method := "post"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}`)
  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 
{
  "current_state": "string",
  "host": "string",
  "id": "string",
  "name": "string",
  "owner": "string"
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a virtual machine in one of the hosts for the orchestrator:

/api/v1/orchestrator/machines Authorized

This endpoint creates a virtual machine in one of the hosts for the orchestrator

Parameters
request Create Virtual Machine Request body 
{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}
Request examples
/v1/orchestrator/machines Authorized 
curl --location 'http://localhost/api/v1/orchestrator/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/machines");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}");
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/orchestrator/machines"
  method := "post"
  payload := strings.NewReader(`{
  "architecture": "string",
  "catalog_manifest": "*CreateCatalogVirtualMachineRequest",
  "name": "string",
  "owner": "string",
  "packer_template": "*CreatePackerVirtualMachineRequest",
  "start_on_create": "bool",
  "vagrant_box": "*CreateVagrantMachineRequest"
}`)
  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 
{
  "current_state": "string",
  "host": "string",
  "id": "string",
  "name": "string",
  "owner": "string"
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host reverse proxy configuration:

/api/v1/orchestrator/hosts/{id}/reverse-proxy Authorized

This endpoint returns orchestrator host reverse proxy configuration

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy");
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}/reverse-proxy"
  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 
{
  "enabled": "bool",
  "host": "string",
  "port": "string"
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host reverse proxy hosts:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized

This endpoint returns orchestrator host reverse proxy hosts

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts");
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}/reverse-proxy/hosts"
  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 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Gets orchestrator host reverse proxy hosts:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint returns orchestrator host reverse proxy hosts

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
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}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  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 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Creates a orchestrator host reverse proxy host:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized

This endpoint creates a orchestrator host reverse proxy host

Parameters
request Create Host Reverse Proxy Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}");
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/orchestrator/hosts/{id}/reverse-proxy/hosts"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "http_routes": "[]*ReverseProxyHostHttpRoute",
  "port": "string",
  "tcp_route": "*ReverseProxyHostTcpRoute",
  "tls": "*ReverseProxyHostTls"
}`)
  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 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Updates an orchestrator host reverse proxy host:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint updates an orchestrator host reverse proxy host

Parameters
request Update Host Reverse Proxy Host Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
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/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "put"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  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 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host reverse proxy host:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id} Authorized

This endpoint deletes an orchestrator host reverse proxy host

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}");
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}/reverse-proxy/hosts/{reverse_proxy_host_id}"
  method := "delete"
  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"
}
Upserts an orchestrator host reverse proxy host http route:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes Authorized

This endpoint upserts an orchestrator host reverse proxy host http route

Parameters
request Upsert Host Reverse Proxy Host Http Routes Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
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/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  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 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Deletes an orchestrator host reverse proxy host http route:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id} Authorized

This endpoint deletes an orchestrator host reverse proxy host http route

Parameters
id Host ID required path reverse_proxy_host_id Reverse Proxy Host ID required path route_id Route ID required path
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}");
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}/reverse-proxy/hosts/{reverse_proxy_host_id}/http_routes/{route_id}"
  method := "delete"
  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"
}
Update an orchestrator host reverse proxy host tcp route:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route Authorized

This endpoint updates an orchestrator host reverse proxy host tcp route

Parameters
request Update Host Reverse Proxy Host tcp Routes Request body 
{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}
Request examples
/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}");
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/orchestrator/hosts/{id}/reverse-proxy/hosts/{reverse_proxy_host_id}/tcp_route"
  method := "post"
  payload := strings.NewReader(`{
  "cors": "*ReverseProxyHostCors",
  "host": "string",
  "port": "string",
  "tls": "*ReverseProxyHostTls"
}`)
  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 
[
  {
    "cors": "*ReverseProxyHostCors",
    "host": "string",
    "http_routes": "[]*ReverseProxyHostHttpRoute",
    "id": "string",
    "port": "string",
    "tcp_route": "*ReverseProxyHostTcpRoute",
    "tls": "*ReverseProxyHostTls"
  }
]

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Restarts orchestrator host reverse proxy:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/restart Authorized

This endpoint restarts orchestrator host reverse proxy

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/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/orchestrator/hosts/{id}/reverse-proxy/restart"
  method := "put"
  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"
}
Enables orchestrator host reverse proxy:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable Authorized

This endpoint enables orchestrator host reverse proxy

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/enable");
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}/reverse-proxy/enable"
  method := "put"
  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"
}
Disables orchestrator host reverse proxy:

/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable Authorized

This endpoint disables orchestrator host reverse proxy

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/orchestrator/hosts/{id}/reverse-proxy/disable");
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}/reverse-proxy/disable"
  method := "put"
  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 orchestrator host catalog cache:

/api/v1/orchestrator/hosts/{id}/catalog/cache Authorized

This endpoint returns orchestrator host catalog cache

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache");
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}/catalog/cache"
  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"
}
Deletes an orchestrator host cache items:

/api/v1/orchestrator/hosts/{id}/catalog/cache Authorized

This endpoint deletes an orchestrator host cache items

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache");
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}/catalog/cache"
  method := "delete"
  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"
}
Deletes an orchestrator host cache item and all its children:

/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id} Authorized

This endpoint deletes an orchestrator host cache item and all its children

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}");
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}/catalog/cache/{catalog_id}"
  method := "delete"
  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"
}
Deletes an orchestrator host cache item and all its children:

/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version} Authorized

This endpoint deletes an orchestrator host cache item and all its children

Parameters
id Host ID required path catalog_id Catalog ID required path catalog_version Catalog Version required path
Request examples
/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version} Authorized 
curl --location 'http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}' 
--header 'Authorization ••••••'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/orchestrator/hosts/{id}/catalog/cache/{catalog_id}/{catalog_version}");
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}/catalog/cache/{catalog_id}/{catalog_version}"
  method := "delete"
  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"
}