Project-FiFo

The Project-FiFo Developer Hub

Welcome to the Project-FiFo developer hub. You'll find comprehensive guides and documentation to help you start working with Project-FiFo as quickly as possible, as well as support if you get stuck. Let's jump right in!

Get Started    
Suggest Edits

get

See Get Roles for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/roles/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/roles/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/roles/");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/roles/
curl --request POST \
  --url http://example.com/api/3/roles/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/roles/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/roles/");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/roles/uuid
curl --request GET \
  --url http://example.com/api/3/roles/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/roles/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/roles/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/roles/uuid
curl --request DELETE \
  --url http://example.com/api/3/roles/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/roles/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/roles/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/permissions/{permission}

 
putexample.com/api/3/roles/uuid/permissions/permission
curl --request PUT \
  --url http://example.com/api/3/roles/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/roles/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/roles/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid/permissions/permission"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/roles/uuid/permissions/permission
curl --request DELETE \
  --url http://example.com/api/3/roles/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/roles/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/roles/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/roles/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/roles/uuid/permissions/permission"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get User for the fields available for full-list-fields.

 
get/
curl --request GET \
  --url http://example.com/api/3/users/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/users/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/users/");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

Creates a new user

 
postexample.com/api/3/users/
curl --request POST \
  --url http://example.com/api/3/users/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/users/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/users/");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/user/{uuid}

 
getexample.com/api/3/users/user/uuid
curl --request GET \
  --url http://example.com/api/3/users/user/uuid
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/users/user/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/users/user/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/users/user/uuid
curl --request PUT \
  --url http://example.com/api/3/users/user/uuid
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/users/user/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/users/user/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/users/user/uuid
curl --request DELETE \
  --url http://example.com/api/3/users/user/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/user/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/user/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/user/{uuid}/permissions/{permission}

 
Suggest Edits

get

Tests if a user has is allowed to perform an action.
Please note that 403 here does not mean the user is not allowed
but that the requesting token was not allowed to test for the client!

 
getexample.com/api/3/users/user/uuid/permissions/permission
curl --request GET \
  --url http://example.com/api/3/users/user/uuid/permissions/permission
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/users/user/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/users/user/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid/permissions/permission"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/users/user/uuid/permissions/permission
curl --request PUT \
  --url http://example.com/api/3/users/user/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/users/user/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/users/user/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid/permissions/permission"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/users/user/uuid/permissions/permission
curl --request DELETE \
  --url http://example.com/api/3/users/user/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/user/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/user/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid/permissions/permission"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/user/{uuid}/role/{role}

 
putexample.com/api/3/users/user/uuid/role/role
curl --request PUT \
  --url http://example.com/api/3/users/user/uuid/role/role
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/users/user/uuid/role/role' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid/role/role")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/users/user/uuid/role/role");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid/role/role"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/users/user/uuid/role/role
curl --request DELETE \
  --url http://example.com/api/3/users/user/uuid/role/role
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/user/uuid/role/role' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/user/uuid/role/role")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/user/uuid/role/role");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/user/uuid/role/role"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/keys

 
putexample.com/api/3/users/uuid/keys
curl --request PUT \
  --url http://example.com/api/3/users/uuid/keys
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/users/uuid/keys' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/keys")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/users/uuid/keys");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/keys"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/keys/{key-id}

 
deleteexample.com/api/3/users/uuid/keys/key-id
curl --request DELETE \
  --url http://example.com/api/3/users/uuid/keys/key-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/uuid/keys/key-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/keys/key-id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/uuid/keys/key-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/keys/key-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/yubikeys

 
putexample.com/api/3/users/uuid/yubikeys
curl --request PUT \
  --url http://example.com/api/3/users/uuid/yubikeys
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/users/uuid/yubikeys' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/yubikeys")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/users/uuid/yubikeys");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/yubikeys"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/yubikeys/{key-id}

 
deleteexample.com/api/3/users/uuid/yubikeys/key-id
curl --request DELETE \
  --url http://example.com/api/3/users/uuid/yubikeys/key-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/uuid/yubikeys/key-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/yubikeys/key-id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/uuid/yubikeys/key-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/yubikeys/key-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/orgs/{org}

 
Suggest Edits

put

The first joined Organisation
will automatically be set as active. Any further Organisations
need to be selected as active by passing the 'active' parameter
in a JSON.

 
putexample.com/api/3/users/uuid/orgs/org
curl --request PUT \
  --url http://example.com/api/3/users/uuid/orgs/org
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/users/uuid/orgs/org' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/orgs/org")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/users/uuid/orgs/org");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/orgs/org"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/users/uuid/orgs/org
curl --request DELETE \
  --url http://example.com/api/3/users/uuid/orgs/org
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/uuid/orgs/org' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/orgs/org")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/uuid/orgs/org");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/orgs/org"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/tokens

 
Suggest Edits

post

Crates a API token for a user with a given scope, please keep in
mind that the reply to this request is THE ONLY TIME the bearer
token can be accessed!

 
postexample.com/api/3/users/uuid/tokens
curl --request POST \
  --url http://example.com/api/3/users/uuid/tokens
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/users/uuid/tokens' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/tokens")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/users/uuid/tokens");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/tokens"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/tokens/{token-id}

 
Suggest Edits

delete

This applies equally for access and refresh tokens

 
deleteexample.com/api/3/users/uuid/tokens/token-id
curl --request DELETE \
  --url http://example.com/api/3/users/uuid/tokens/token-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/users/uuid/tokens/token-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/users/uuid/tokens/token-id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/users/uuid/tokens/token-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/users/uuid/tokens/token-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See 'Get Network' for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/networks/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/networks/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/networks/");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/networks/
curl --request POST \
  --url http://example.com/api/3/networks/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/networks/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/networks/");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/networks/uuid
curl --request GET \
  --url http://example.com/api/3/networks/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/networks/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/networks/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/networks/uuid
curl --request DELETE \
  --url http://example.com/api/3/networks/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/networks/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/networks/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/iprange/{iprange}

 
putexample.com/api/3/networks/uuid/iprange/iprange
curl --request PUT \
  --url http://example.com/api/3/networks/uuid/iprange/iprange
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/networks/uuid/iprange/iprange' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid/iprange/iprange")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/networks/uuid/iprange/iprange");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid/iprange/iprange"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/networks/uuid/iprange/iprange
curl --request DELETE \
  --url http://example.com/api/3/networks/uuid/iprange/iprange
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/networks/uuid/iprange/iprange' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/networks/uuid/iprange/iprange")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/networks/uuid/iprange/iprange");

xhr.send(data);
import requests

url = "http://example.com/api/3/networks/uuid/iprange/iprange"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Client for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/clients/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/clients/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/clients/");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/clients/
curl --request POST \
  --url http://example.com/api/3/clients/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/clients/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/clients/");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/clients/uuid
curl --request GET \
  --url http://example.com/api/3/clients/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/clients/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/clients/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/clients/uuid
curl --request PUT \
  --url http://example.com/api/3/clients/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://example.com/api/3/clients/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/clients/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/clients/uuid
curl --request DELETE \
  --url http://example.com/api/3/clients/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/clients/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/clients/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/permissions/{permission}

 
Suggest Edits

get

Please note that 403 here does not mean the client is not allowed but that the
requesting token was not allowed to test for the client!

 
getexample.com/api/3/clients/uuid/permissions/permission
curl --request GET \
  --url http://example.com/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/clients/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/clients/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/permissions/permission"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
putexample.com/api/3/clients/uuid/permissions/permission
curl --request PUT \
  --url http://example.com/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/clients/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/clients/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/permissions/permission"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/clients/uuid/permissions/permission
curl --request DELETE \
  --url http://example.com/api/3/clients/uuid/permissions/permission
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/clients/uuid/permissions/permission' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/permissions/permission")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/clients/uuid/permissions/permission");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/permissions/permission"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/uris

 
postexample.com/api/3/clients/uuid/uris
curl --request POST \
  --url http://example.com/api/3/clients/uuid/uris
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/clients/uuid/uris' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/uris")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/clients/uuid/uris");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/uris"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/uris/{id}

 
deleteexample.com/api/3/clients/uuid/uris/id
curl --request DELETE \
  --url http://example.com/api/3/clients/uuid/uris/id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/clients/uuid/uris/id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/clients/uuid/uris/id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/clients/uuid/uris/id");

xhr.send(data);
import requests

url = "http://example.com/api/3/clients/uuid/uris/id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

Lists all Groupings visible to the user, either by uuid or objects.

 
get/
curl --request GET \
  --url http://example.com/api/3/groupings/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/groupings/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/groupings/");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/groupings/uuid
curl --request GET \
  --url http://example.com/api/3/groupings/uuid
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/groupings/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/groupings/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/elements/{other}

 
putexample.com/api/3/groupings/uuid/elements/other
curl --request PUT \
  --url http://example.com/api/3/groupings/uuid/elements/other
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/groupings/uuid/elements/other' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/elements/other")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/groupings/uuid/elements/other");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/elements/other"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/groupings/uuid/elements/other
curl --request DELETE \
  --url http://example.com/api/3/groupings/uuid/elements/other
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/groupings/uuid/elements/other' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/elements/other")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/groupings/uuid/elements/other");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/elements/other"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/config/{path}

 
putexample.com/api/3/groupings/uuid/config/path
curl --request PUT \
  --url http://example.com/api/3/groupings/uuid/config/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/groupings/uuid/config/path' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/config/path")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/groupings/uuid/config/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/config/path"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/groupings/uuid/config/path
curl --request DELETE \
  --url http://example.com/api/3/groupings/uuid/config/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/groupings/uuid/config/path' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/config/path")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/groupings/uuid/config/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/config/path"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/metadata/{path}

 
putexample.com/api/3/groupings/uuid/metadata/path
curl --request PUT \
  --url http://example.com/api/3/groupings/uuid/metadata/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/groupings/uuid/metadata/path' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/metadata/path")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/groupings/uuid/metadata/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/metadata/path"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/groupings/uuid/metadata/path
curl --request DELETE \
  --url http://example.com/api/3/groupings/uuid/metadata/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/groupings/uuid/metadata/path' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/groupings/uuid/metadata/path")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/groupings/uuid/metadata/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/groupings/uuid/metadata/path"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Dataset for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/datasets/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/datasets/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/datasets/");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/datasets/
curl --request POST \
  --url http://example.com/api/3/datasets/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/datasets/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/datasets/");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/datasets/uuid
curl --request GET \
  --url http://example.com/api/3/datasets/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/datasets/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/datasets/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/datasets/uuid
curl --request DELETE \
  --url http://example.com/api/3/datasets/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/datasets/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/datasets/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

put

This is the 1st step of a dataset import from a local file

 
putexample.com/api/3/datasets/uuid
curl --request PUT \
  --url http://example.com/api/3/datasets/uuid
var request = require("request");

var options = { method: 'PUT', url: 'http://example.com/api/3/datasets/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/datasets/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/dataset.gz

 
getexample.com/api/3/datasets/uuid/dataset.gz
curl --request GET \
  --url http://example.com/api/3/datasets/uuid/dataset.gz
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/datasets/uuid/dataset.gz' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/dataset.gz")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/datasets/uuid/dataset.gz");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/dataset.gz"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

put

This is the 2nd step of a dataset import from a local file

 
putexample.com/api/3/datasets/uuid/dataset.gz
curl --request PUT \
  --url http://example.com/api/3/datasets/uuid/dataset.gz
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/datasets/uuid/dataset.gz' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/dataset.gz")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/datasets/uuid/dataset.gz");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/dataset.gz"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/networks/{nic}

 
putexample.com/api/3/datasets/uuid/networks/nic
curl --request PUT \
  --url http://example.com/api/3/datasets/uuid/networks/nic
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/datasets/uuid/networks/nic' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/networks/nic")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/datasets/uuid/networks/nic");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/networks/nic"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/datasets/uuid/networks/nic
curl --request DELETE \
  --url http://example.com/api/3/datasets/uuid/networks/nic
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/datasets/uuid/networks/nic' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/datasets/uuid/networks/nic")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/datasets/uuid/networks/nic");

xhr.send(data);
import requests

url = "http://example.com/api/3/datasets/uuid/networks/nic"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Org for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/orgs/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/orgs/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/orgs/");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/orgs/
curl --request POST \
  --url http://example.com/api/3/orgs/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/orgs/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/orgs/");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/orgs/uuid
curl --request GET \
  --url http://example.com/api/3/orgs/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/orgs/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/orgs/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/orgs/uuid
curl --request DELETE \
  --url http://example.com/api/3/orgs/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/orgs/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/orgs/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/accounting

 
Suggest Edits

get

This will grab accounting data for a period between start and end.
The data presented will include all data points for every resource
that existed in this timeframe not only those in the timeframe.
This allows reconstructing the entire situation during the time
frame, including resources that were created before and destroyed
after the period.

 
getexample.com/api/3/orgs/uuid/accounting
curl --request GET \
  --url http://example.com/api/3/orgs/uuid/accounting
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/orgs/uuid/accounting' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/accounting")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/orgs/uuid/accounting");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/accounting"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/user_create

 
Suggest Edits

put

This trigger is executed when a new user is created from someone
who belongs to an org

 
putexample.com/api/3/orgs/uuid/triggers/user_create
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/triggers/user_create
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/triggers/user_create' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/user_create")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/triggers/user_create");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/user_create"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/dataset_create

 
Suggest Edits

post

This trigger is executed when a new dataset is created from someone
who belongs to this org

 
postexample.com/api/3/orgs/uuid/triggers/dataset_create
curl --request POST \
  --url http://example.com/api/3/orgs/uuid/triggers/dataset_create
var request = require("request");

var options = { method: 'POST',
  url: 'http://example.com/api/3/orgs/uuid/triggers/dataset_create' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/dataset_create")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/orgs/uuid/triggers/dataset_create");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/dataset_create"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/vm_create

 
Suggest Edits

put

This trigger is executed when a new VM is created by someone who
belongs to this org

 
putexample.com/api/3/orgs/uuid/triggers/vm_create
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/triggers/vm_create
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/triggers/vm_create' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/vm_create")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/triggers/vm_create");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/vm_create"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/triggers/{trigger-id}

 
deleteexample.com/api/3/orgs/uuid/triggers/trigger-id
curl --request DELETE \
  --url http://example.com/api/3/orgs/uuid/triggers/trigger-id
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/orgs/uuid/triggers/trigger-id' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/triggers/trigger-id")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/orgs/uuid/triggers/trigger-id");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/triggers/trigger-id"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/resources/{resource}

 
Suggest Edits

put

Increases or decreases resources for an org.

 
putexample.com/api/3/orgs/uuid/resources/resource
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/resources/resource
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/resources/resource' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/resources/resource")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/resources/resource");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/resources/resource"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/docker/networks/{scope}

 
putexample.com/api/3/orgs/uuid/docker/networks/scope
curl --request PUT \
  --url http://example.com/api/3/orgs/uuid/docker/networks/scope
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/orgs/uuid/docker/networks/scope' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/orgs/uuid/docker/networks/scope")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/orgs/uuid/docker/networks/scope");

xhr.send(data);
import requests

url = "http://example.com/api/3/orgs/uuid/docker/networks/scope"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See 'get hypervisor' for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/hypervisors/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/hypervisors/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/hypervisors/");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/hypervisors/uuid
curl --request GET \
  --url http://example.com/api/3/hypervisors/uuid
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/hypervisors/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/hypervisors/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

delete

Every vm still residing on this hypervisor
will either be put in 'limbo' when at least one full backup exists,
or be deleted if not.

 
deleteexample.com/api/3/hypervisors/uuid
curl --request DELETE \
  --url http://example.com/api/3/hypervisors/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/hypervisors/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/hypervisors/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/characteristics/{path}

 
Suggest Edits

put

this can be later used on rules to match against.

 
putexample.com/api/3/hypervisors/uuid/characteristics/path
curl --request PUT \
  --url http://example.com/api/3/hypervisors/uuid/characteristics/path
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/hypervisors/uuid/characteristics/path' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/characteristics/path")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/hypervisors/uuid/characteristics/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/characteristics/path"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/hypervisors/uuid/characteristics/path
curl --request DELETE \
  --url http://example.com/api/3/hypervisors/uuid/characteristics/path
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/hypervisors/uuid/characteristics/path' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/characteristics/path")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/hypervisors/uuid/characteristics/path");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/characteristics/path"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/config

 
putexample.com/api/3/hypervisors/uuid/config
curl --request PUT \
  --url http://example.com/api/3/hypervisors/uuid/config
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/hypervisors/uuid/config' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/config")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/hypervisors/uuid/config");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/config"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/metrics

 
getexample.com/api/3/hypervisors/uuid/metrics
curl --request GET \
  --url http://example.com/api/3/hypervisors/uuid/metrics
var request = require("request");

var options = { method: 'GET',
  url: 'http://example.com/api/3/hypervisors/uuid/metrics' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/hypervisors/uuid/metrics")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/hypervisors/uuid/metrics");

xhr.send(data);
import requests

url = "http://example.com/api/3/hypervisors/uuid/metrics"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

This endpoint serves both 'Authorization Code Request' and the
'Implict Request' parts of the OAuth 2 workflow depending on the
response_type provided.

 
get/auth
curl --request GET \
  --url http://example.com/api/3/oauth2/auth
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/oauth2/auth' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/oauth2/auth")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/oauth2/auth");

xhr.send(data);
import requests

url = "http://example.com/api/3/oauth2/auth"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
postexample.com/api/3/oauth2/auth
curl --request POST \
  --url http://example.com/api/3/oauth2/auth
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/oauth2/auth' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/oauth2/auth")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/oauth2/auth");

xhr.send(data);
import requests

url = "http://example.com/api/3/oauth2/auth"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

This endpoint serves the following parts of the OAuth workflow, please
see the linked specifications for details as it does not fit the swagger
spec definition language.

 
postexample.com/api/3/oauth2/token
curl --request POST \
  --url http://example.com/api/3/oauth2/token
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/oauth2/token' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/oauth2/token")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/oauth2/token");

xhr.send(data);
import requests

url = "http://example.com/api/3/oauth2/token"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

See Get Package for the fields available for full-list-fields.

 
get/
curl --request GET \
  --url http://example.com/api/3/packages/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/packages/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/packages/");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

Requirements
'requirements' is an array of objects as with the following atributes:
'WEIGHT'
A number (positive or negative) or the string "most", "cant" for strong
enforcement or "scale" and "random" must, cant, and <number> rules
This rules simply compare an attribute of the hypervisor against a
value and either enforces a the rule (must/cant) or gives out points,
both positive and negative to rate the found hypervisors.
attribute
The attribute to check on the hypervisors, this can be a json like
path so for example "characteristics.colour" will look up colour in
the hypervisors characteristics
Value
The value to check against, this can be a number, a string, or an array.
condition
One of:

=, > - Checks if the value of attribute is larger (or equal) to the
value
=<, < - Checks if the value of attribute is smaller (or equal) to the
value
=:= - Checks if the value of attribute is equal to the value
=/= - Checks if the value of attribute is not equal to the value
"subset" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"superset" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"disjoint" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"element" - Checks if the value of attribute is a subset of value
(requires value to be an array)
"allowed" - Checks if the value of attribute is a subset of value
(requires value to be an array)
scale rules
This rules linearly map an attributes value onto a given scale and
give the result as points for hypervisor selection.
attribute
The attribute to check on the hypervisors, this can be a json like
path so for example "characteristics.cores" will look up cores in the
hypervisors characteristics This must be an numeric value towork
low, and high
The lowest and highest number of the scale, to map against.
random ruleS
This rules simply generate a random number on a given scale, this
allows making non deterministic rules. The resulting number is used
as points for hypervisor selection.
low, and high
The lowest and highest number the random number is generated from.

 
postexample.com/api/3/packages/
curl --request POST \
  --url http://example.com/api/3/packages/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/packages/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/packages/");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/packages/uuid
curl --request GET \
  --url http://example.com/api/3/packages/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/packages/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/packages/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/packages/uuid
curl --request DELETE \
  --url http://example.com/api/3/packages/uuid
var request = require("request");

var options = { method: 'DELETE',
  url: 'http://example.com/api/3/packages/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/packages/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/packages/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/packages/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
get/
curl --request GET \
  --url http://example.com/api/3/scopes/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/scopes/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/scopes/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = JSON.stringify(false);

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/scopes/");

xhr.send(data);
import requests

url = "http://example.com/api/3/scopes/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

get

see get vm for the fields available for 'full-list-fields'

 
get/
curl --request GET \
  --url http://example.com/api/3/vms/
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/vms/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/vms/");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

post

Most of the keys in config
are self-explanatory the one noteworthy is networks however. it is
a map of nics (provided by the dataset) to UUIDs of networks (
not ip ranges!).

 
postexample.com/api/3/vms/
curl --request POST \
  --url http://example.com/api/3/vms/
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/vms/' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
getexample.com/api/3/vms/uuid
curl --request GET \
  --url http://example.com/api/3/vms/uuid
var request = require("request");

var options = { method: 'GET', url: 'http://example.com/api/3/vms/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("GET", "http://example.com/api/3/vms/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid"

response = requests.request("GET", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
deleteexample.com/api/3/vms/uuid
curl --request DELETE \
  --url http://example.com/api/3/vms/uuid
var request = require("request");

var options = { method: 'DELETE', url: 'http://example.com/api/3/vms/uuid' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("DELETE", "http://example.com/api/3/vms/uuid");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid"

response = requests.request("DELETE", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
 
Suggest Edits

post

This is the same as the normal Create an VM request however it stops
before sending the request to the hypervisor. So no VM is ever created
however it does check if the VM could be created.
It needs to be noted that both false positives and false negatives
can occur so this is a good approximation but should not be taken as
a definite. False positive are more likely then false negatives.

 
postexample.com/api/3/vms/dry_run
curl --request POST \
  --url http://example.com/api/3/vms/dry_run
var request = require("request");

var options = { method: 'POST', url: 'http://example.com/api/3/vms/dry_run' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/dry_run")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("POST", "http://example.com/api/3/vms/dry_run");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/dry_run"

response = requests.request("POST", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/state

 
putexample.com/api/3/vms/uuid/state
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/state
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/state' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/state")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/state");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/state"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/console

 
putexample.com/api/3/vms/uuid/console
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/console
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/console' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/console")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/console");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/console"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/package

 
putexample.com/api/3/vms/uuid/package
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/package
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/package' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/package")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/package");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/package"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/config

 
putexample.com/api/3/vms/uuid/config
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/config
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/config' };

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});
require 'uri'
require 'net/http'

url = URI("http://example.com/api/3/vms/uuid/config")

http = Net::HTTP.new(url.host, url.port)

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body
var data = null;

var xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener("readystatechange", function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open("PUT", "http://example.com/api/3/vms/uuid/config");

xhr.send(data);
import requests

url = "http://example.com/api/3/vms/uuid/config"

response = requests.request("PUT", url)

print(response.text)
A binary file was returned

You couldn't be authenticated

Try the API to see results
 
Suggest Edits

/{uuid}/owner

 
putexample.com/api/3/vms/uuid/owner
curl --request PUT \
  --url http://example.com/api/3/vms/uuid/owner
var request = require("request");

var options = { method: 'PUT',
  url: 'http://example.com/api/3/vms/uuid/owner' };

request(options, function (error, response, body) {