Gets all the virtual machines

/api/v1/machines Authorized

This endpoint returns all the virtual machines

Parameters

Name	Type	In	Required	Description
`filter`	`header`	header	optional	-

Request examples

      
      /v1/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

{ object }

Gets a virtual machine

/api/v1/machines/{id} Authorized

This endpoint returns a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

{ object }

Starts a virtual machine

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

This endpoint starts a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/start
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/start' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Stops a virtual machine

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

This endpoint stops a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`force`	`query`	query	optional	-

Request examples

      
      /v1/machines/{id}/stop
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/stop' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Restarts a virtual machine

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

This endpoint restarts a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/restart
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/restart' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Suspends a virtual machine

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

This endpoint suspends a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/suspend
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/suspend' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Resumes a virtual machine

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

This endpoint resumes a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/resume
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/resume' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Reset a virtual machine

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

This endpoint reset a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/reset
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/reset' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Pauses a virtual machine

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

This endpoint pauses a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/pause
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/pause' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Put, "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 := "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

{ object }

{ object }

{ object }

Deletes a virtual machine

/api/v1/machines/{id} Authorized

This endpoint deletes a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

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

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

Request examples

      
      /v1/machines/{id}/status
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
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

{ object }

{ object }

{ object }

Configures a virtual machine

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

This endpoint configures a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`configRequest`	`object`	body	optional	Machine Set Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/set
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/set' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Clones a virtual machine

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

This endpoint clones a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`configRequest`	`object`	body	optional	Machine Clone Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/clone
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/clone' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Executes a command on a virtual machine

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

This endpoint executes a command on a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`executeRequest`	`object`	body	optional	Machine Execute Command Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/execute
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/execute' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Uploads a file to a virtual machine

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

This endpoint executes a command on a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`executeRequest`	`object`	body	optional	Machine Upload file Command Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/upload
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/upload' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Renames a virtual machine

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

This endpoint Renames a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`renameRequest`	`object`	body	optional	Machine Rename Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/rename
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/rename' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Registers a virtual machine

/api/v1/machines/register Authorized

This endpoint registers a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`registerRequest`	`object`	body	optional	Machine Register Request
Schema `{ object }`

Request examples

      
      /v1/machines/register
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/register' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Unregister a virtual machine

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

This endpoint unregister a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`unregisterRequest`	`object`	body	optional	Machine Unregister Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/unregister
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/unregister' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Creates a virtual machine

/api/v1/machines Authorized

This endpoint creates a virtual machine

Parameters

Name	Type	In	Required	Description
`createRequest`	`object`	body	optional	New Machine Request
Schema `{ object }`

Request examples

      
      /v1/machines
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

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("{ object }");
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(`{ object }`)
  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

{ object }

{ object }

{ object }

Creates a virtual machine asynchronously

/api/v1/machines/async Authorized

This endpoint creates a virtual machine in the background and returns a Job ID to track progress

Parameters

Name	Type	In	Required	Description
`createRequest`	`object`	body	optional	New Machine Request
Schema `{ object }`

Request examples

      
      /v1/machines/async
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/async' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

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

{ object }

{ object }

{ object }

Creates a snapshot for a virtual machine

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

This endpoint creates a snapshot for a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`createRequest`	`object`	body	optional	Create Snapshot Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/snapshots' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

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

{ object }

{ object }

{ object }

Deletes a snapshot of a virtual machine

/api/v1/machines/{id}/snapshots/{snapshot_id} Authorized

This endpoint deletes a snapshot of a virtual machine

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`snapshot_id`	`string`	path	required	Snapshot ID

Request examples

      
      /v1/machines/{id}/snapshots/{snapshot_id}
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/snapshots/{snapshot_id}' 
--header 'Authorization ••••••'

var client = new HttpClient();

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

{ object }

{ object }

Deletes all snapshots of a virtual machine

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

This endpoint deletes all snapshots of a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/snapshots' 
--header 'Authorization ••••••'

var client = new HttpClient();

var request = new HttpRequestMessage(HttpMethod.Delete, "http://localhost/api/v1/machines/{id}/snapshots");
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}/snapshots"
  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

{ object }

{ object }

Lists snapshots of a virtual machine

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

This endpoint lists snapshots of a virtual machine

Parameters

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

Request examples

      
      /v1/machines/{id}/snapshots
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/snapshots' 
--header 'Authorization ••••••'

var client = new HttpClient();

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

{ object }

{ object }

{ object }

Reverts a virtual machine to a snapshot

/api/v1/machines/{id}/snapshots/{snapshot_id}/revert Authorized

This endpoint reverts a virtual machine to a snapshot

Parameters

Name	Type	In	Required	Description
`id`	`string`	path	required	Machine ID
`snapshot_id`	`string`	path	required	Snapshot ID
`revertRequest`	`object`	body	optional	Revert Snapshot Request
Schema `{ object }`

Request examples

      
      /v1/machines/{id}/snapshots/{snapshot_id}/revert
      
      Authorized
      
    

        
            
              cURL
            
          

            
              C#
            
          

            
              Go
            
          

      
curl --location 'http://localhost/api/v1/machines/{id}/snapshots/{snapshot_id}/revert' 
--header 'Authorization ••••••'
--header 'Content-Type: application/json' 
--data '{ object }'

var client = new HttpClient();

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

{ object }

{ object }

{ object }

Machines endpoints

Gets all the virtual machines

Parameters

Gets a virtual machine

Parameters

Starts a virtual machine

Parameters

Stops a virtual machine

Parameters

Restarts a virtual machine

Parameters

Suspends a virtual machine

Parameters

Resumes a virtual machine

Parameters

Reset a virtual machine

Parameters

Pauses a virtual machine

Parameters

Deletes a virtual machine

Parameters

Get the current state of a virtual machine

Parameters

Configures a virtual machine

Parameters

Clones a virtual machine

Parameters

Executes a command on a virtual machine

Parameters

Uploads a file to a virtual machine

Parameters

Renames a virtual machine

Parameters

Registers a virtual machine

Parameters

Unregister a virtual machine

Parameters

Creates a virtual machine

Parameters

Creates a virtual machine asynchronously

Parameters

Creates a snapshot for a virtual machine

Parameters

Deletes a snapshot of a virtual machine

Parameters

Deletes all snapshots of a virtual machine

Parameters

Lists snapshots of a virtual machine

Parameters

Reverts a virtual machine to a snapshot

Parameters

Cookie Consent