Get Started

Machines

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

Machines endpoints

This document contains the endpoints for the Machines category.

Gets all the virtual machines:

/api/v1/machines Authorized

This endpoint returns all the virtual machines

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/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/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"
}
Gets a virtual machine:

/api/v1/machines/{id} Authorized

This endpoint returns a virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/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/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"
}
Starts a virtual machine:

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

This endpoint starts a virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/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/machines/{id}/start"
  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 
{
  "id": "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 a virtual machine:

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

This endpoint stops a virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/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/machines/{id}/stop"
  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 
{
  "id": "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"
}
Restarts a virtual machine:

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

This endpoint restarts a virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/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/machines/{id}/restart"
  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 
{
  "id": "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"
}
Suspends a virtual machine:

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

This endpoint suspends a virtual machine

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


var client = new HttpClient();

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

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

This endpoint resumes a virtual machine

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


var client = new HttpClient();

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

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

This endpoint reset a virtual machine

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


var client = new HttpClient();

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

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

This endpoint pauses a virtual machine

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


var client = new HttpClient();

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

/api/v1/machines/{id} Authorized

This endpoint deletes a virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/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/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 the current state of a virtual machine:

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

This endpoint returns the current state of a virtual machine

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


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/v1/machines/{id}/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/machines/{id}/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 
{
  "id": "string",
  "ip_configured": "string",
  "status": "string"
}

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

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

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

This endpoint configures a virtual machine

Parameters
id Machine ID required path
configRequest Machine Set Request body 
{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "owner": "string"
}
Request examples
/v1/machines/{id}/set Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/set' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "owner": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/set");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "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/machines/{id}/set"
  method := "put"
  payload := strings.NewReader(`{
  "operations": "[]*VirtualMachineConfigRequestOperation",
  "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 
{
  "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"
}
Clones a virtual machine:

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

This endpoint clones a virtual machine

Parameters
id Machine ID required path
configRequest Machine Clone Request body 
{
  "clone_name": "string"
}
Request examples
/v1/machines/{id}/clone Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/clone' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "clone_name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/clone");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "clone_name": "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/machines/{id}/clone"
  method := "put"
  payload := strings.NewReader(`{
  "clone_name": "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 
{
  "error": "string",
  "id": "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 on a virtual machine:

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

This endpoint executes a command on a virtual machine

Parameters
id Machine ID required path
executeRequest Machine Execute Command Request body 
{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "string"
}
Request examples
/v1/machines/{id}/execute Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/execute' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/execute");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "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/machines/{id}/execute"
  method := "put"
  payload := strings.NewReader(`{
  "command": "string",
  "environment_variables": "map[string]string",
  "script": "*VirtualMachineExecuteCommandScript",
  "use_ssh": "bool",
  "use_sudo": "bool",
  "user": "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 
{
  "error": "string",
  "exit_code": "int",
  "stderr": "string",
  "stdout": "string"
}

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

{
  "error": "OAuthErrorType",
  "error_description": "string",
  "error_uri": "string"
}
Uploads a file to a virtual machine:

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

This endpoint executes a command on a virtual machine

Parameters
id Machine ID required path
executeRequest Machine Upload file Command Request body 
{
  "path": "string",
  "remote_path": "string"
}
Request examples
/v1/machines/{id}/upload Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/upload' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "path": "string",
  "remote_path": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost/api/v1/machines/{id}/upload");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "path": "string",
  "remote_path": "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/machines/{id}/upload"
  method := "post"
  payload := strings.NewReader(`{
  "path": "string",
  "remote_path": "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 
{
  "error": "string",
  "path": "string"
}

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

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

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

This endpoint Renames a virtual machine

Parameters
id Machine ID required path
renameRequest Machine Rename Request body 
{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "string"
}
Request examples
/v1/machines/{id}/rename Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/rename' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "string"
}'


var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "http://localhost/api/v1/machines/{id}/rename");
request.Headers.Add("Authorization", "••••••");
request.Headers.Add("Content-Type", "application/json");
request.Content = new StringContent("{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "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/machines/{id}/rename"
  method := "put"
  payload := strings.NewReader(`{
  "current_name": "string",
  "description": "string",
  "id": "string",
  "new_name": "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"
}
Registers a virtual machine:

/api/v1/machines/register Authorized

This endpoint registers a virtual machine

Parameters
id Machine ID required path
registerRequest Machine Register Request body 
{
  "delay_applying_restrictions": "bool",
  "force": "bool",
  "machine_name": "string",
  "owner": "string",
  "path": "string",
  "regenerate_source_uuid": "bool",
  "uuid": "string"
}
Request examples
/v1/machines/register Authorized 
curl --location 'http://localhost/api/v1/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/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/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:

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

This endpoint unregister a virtual machine

Parameters
id Machine ID required path
unregisterRequest Machine Unregister Request body 
{
  "clean_source_uuid": "bool",
  "id": "string",
  "owner": "string"
}
Request examples
/v1/machines/{id}/unregister Authorized 
curl --location 'http://localhost/api/v1/machines/{id}/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/machines/{id}/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/machines/{id}/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 
{
  "code": "int",
  "data": "unknown",
  "error": "unknown",
  "operation": "string",
  "success": "bool"
}

{
  "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:

/api/v1/machines Authorized

This endpoint creates a virtual machine

Parameters
createRequest New 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/machines Authorized 
curl --location 'http://localhost/api/v1/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/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/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"
}