NAV Navigation
Shell HTTP JavaScript Node.JS Ruby Python Java

Speckle OpenApi Specs v1.0.0-beta

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Documentation & specifications for the Speckle Server & Speckle Objects.

Base URLs:

Email: SpeckleWorks Web: SpeckleWorks

Authentication

Accounts

Register, Login and more.

UserRegister

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/accounts/register \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/accounts/register HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/accounts/register',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/accounts/register',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/accounts/register',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/accounts/register', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/accounts/register");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /accounts/register

UserRegister

Registers a new user.

Body parameter

{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}

Parameters

Parameter In Type Required Description
body body User true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK New user successfully registered. ResponseUser
400 Bad Request Failed to register a new user. ResponseBase

UserLogin

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/accounts/login \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/accounts/login HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/accounts/login',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/accounts/login',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/accounts/login',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/accounts/login', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/accounts/login");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /accounts/login

UserLogin

Login and get jwt token.

Body parameter

{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}

Parameters

Parameter In Type Required Description
body body User true The only required elements are email and password.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK You've logged in. ResponseUser
400 Bad Request Fail whale. ResponseBase

UserSearch

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/accounts/search \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/accounts/search HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/accounts/search',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/accounts/search',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/accounts/search',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/accounts/search', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/accounts/search");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /accounts/search

UserSearch

Search for a user by substrings of name, surname, and company.

Body parameter

{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}

Parameters

Parameter In Type Required Description
body body User true No elements are required. The name, surname, and company are used to constrain the search.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK New user successfully registered. ResponseUser
400 Bad Request Fail whale. ResponseBase

UserGet

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/accounts \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/accounts HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/accounts',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/accounts',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/accounts',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/accounts', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/accounts");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /accounts

UserGet

Gets your profile.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK New user successfully registered. ResponseUser
400 Bad Request Fail. ResponseBase

UserUpdateProfile

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/accounts \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/accounts HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/accounts',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/accounts',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/accounts',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/accounts', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/accounts");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /accounts

UserUpdateProfile

Updates your profile.

Body parameter

{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}

Parameters

Parameter In Type Required Description
body body User true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK Things are looking good yo. ResponseBase
400 Bad Request Fail. ResponseBase

UserGetProfileById

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/accounts/{userId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/accounts/{userId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/accounts/{userId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/accounts/{userId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/accounts/{userId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/accounts/{userId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/accounts/{userId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /accounts/{userId}

UserGetProfileById

Gets a user's profile.

Parameters

Parameter In Type Required Description
userId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK New user successfully registered. ResponseUser
400 Bad Request Fail whale. ResponseBase

Clients

Create, get and update application clients.

ClientGetAll

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/clients \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/clients HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/clients',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/clients',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/clients',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/clients', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /clients

ClientGetAll

Gets a user's profile.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's clients. ResponseClient
400 Bad Request Fail whale. ResponseBase

ClientCreate

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/clients \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/clients HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/clients',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "role": "string",
  "documentGuid": "string",
  "documentName": "string",
  "documentType": "string",
  "documentLocation": "string",
  "streamId": "string",
  "online": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/clients',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/clients',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/clients', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/clients");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /clients

ClientCreate

Create a client

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "role": "string",
  "documentGuid": "string",
  "documentName": "string",
  "documentType": "string",
  "documentLocation": "string",
  "streamId": "string",
  "online": true
}

Parameters

Parameter In Type Required Description
body body AppClient true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's clients. ResponseClient
400 Bad Request Fail whale. ResponseBase

ClientUpdate

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/clients/{clientId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/clients/{clientId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/clients/{clientId}',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "role": "string",
  "documentGuid": "string",
  "documentName": "string",
  "documentType": "string",
  "documentLocation": "string",
  "streamId": "string",
  "online": true
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/clients/{clientId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/clients/{clientId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/clients/{clientId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/clients/{clientId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /clients/{clientId}

ClientUpdate

Update a client

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "role": "string",
  "documentGuid": "string",
  "documentName": "string",
  "documentType": "string",
  "documentLocation": "string",
  "streamId": "string",
  "online": true
}

Parameters

Parameter In Type Required Description
clientId path string true No description
body body AppClient true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's clients. ResponseClient
400 Bad Request Fail whale. ResponseBase

ClientGet

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/clients/{clientId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/clients/{clientId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/clients/{clientId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/clients/{clientId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/clients/{clientId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/clients/{clientId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/clients/{clientId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /clients/{clientId}

ClientGet

Get a client

Parameters

Parameter In Type Required Description
clientId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK The client. ResponseClient
400 Bad Request Fail whale. ResponseBase

ClientDelete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/api/v1/clients/{clientId} \
  -H 'Accept: application/json'


DELETE http://localhost:3000/api/v1/clients/{clientId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/clients/{clientId}',
  method: 'delete',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/clients/{clientId}',
{
  method: 'DELETE',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.delete 'http://localhost:3000/api/v1/clients/{clientId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.delete('http://localhost:3000/api/v1/clients/{clientId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/clients/{clientId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


DELETE /clients/{clientId}

ClientDelete

Deletes a client

Parameters

Parameter In Type Required Description
clientId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

Projects

Create, get and update projects.

ProjectGetAll

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/projects \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/projects HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/projects',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/projects',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/projects',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/projects', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/projects");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /projects

ProjectGetAll

Gets a user's projects.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's projects. ResponseProject
400 Bad Request Fail whale. ResponseBase

ProjectCreate

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/projects \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/projects HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/projects',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "name": "string",
  "number": "string",
  "users": [],
  "streams": [],
  "subProjects": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/projects',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/projects',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/projects', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/projects");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /projects

Create

Create a project

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "name": "string",
  "number": "string",
  "users": [],
  "streams": [],
  "subProjects": []
}

Parameters

Parameter In Type Required Description
body body Project true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's clients. ResponseProject
400 Bad Request Fail whale. ResponseBase

ProjectUpdate

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/projects/{projectId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/projects/{projectId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/projects/{projectId}',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "name": "string",
  "number": "string",
  "users": [],
  "streams": [],
  "subProjects": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/projects/{projectId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/projects/{projectId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/projects/{projectId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/projects/{projectId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /projects/{projectId}

ProjectUpdate

Update a project

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "name": "string",
  "number": "string",
  "users": [],
  "streams": [],
  "subProjects": []
}

Parameters

Parameter In Type Required Description
projectId path string true No description
body body Project true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's projects. ResponseProject
400 Bad Request Fail whale. ResponseBase

ProjectGet

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/projects/{projectId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/projects/{projectId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/projects/{projectId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/projects/{projectId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/projects/{projectId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/projects/{projectId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/projects/{projectId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /projects/{projectId}

ProjectGet

Get a project

Parameters

Parameter In Type Required Description
projectId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK The client. ResponseProject
400 Bad Request Fail whale. ResponseBase

ProjectDelete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/api/v1/projects/{projectId} \
  -H 'Accept: application/json'


DELETE http://localhost:3000/api/v1/projects/{projectId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/projects/{projectId}',
  method: 'delete',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/projects/{projectId}',
{
  method: 'DELETE',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.delete 'http://localhost:3000/api/v1/projects/{projectId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.delete('http://localhost:3000/api/v1/projects/{projectId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/projects/{projectId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


DELETE /projects/{projectId}

ProjectDelete

Deletes a project

Parameters

Parameter In Type Required Description
projectId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

Comments

Create, get and update comments.

CommentCreate

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/comments/{resourceType}/{resourceId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/comments/{resourceType}/{resourceId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "resource": {},
  "text": "string",
  "assignedTo": [],
  "closed": true,
  "labels": [],
  "view": {},
  "screenshot": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /comments/{resourceType}/{resourceId}

CommentCreate

Creates a comment on a resource.

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "resource": {},
  "text": "string",
  "assignedTo": [],
  "closed": true,
  "labels": [],
  "view": {},
  "screenshot": "string"
}

Parameters

Parameter In Type Required Description
resourceType path string true The resource type you want to comment on.
resourceId path string true The resource id you want to comment on. In the case of streams, it must be a streamId.
body body Comment true No description

Enumerated Values

Parameter Value
resourceType stream
resourceType object
resourceType project
resourceType comment

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseComment
400 Bad Request Fail whale. ResponseBase

CommentGetFromResource

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/comments/{resourceType}/{resourceId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/comments/{resourceType}/{resourceId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/comments/{resourceType}/{resourceId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /comments/{resourceType}/{resourceId}

CommentGetFromResource

Gets the comments from a resource.

Parameters

Parameter In Type Required Description
resourceType path string true The resource type you want to comment on.
resourceId path string true The resource id you want to comment on. In the case of streams, it must be a streamId.

Enumerated Values

Parameter Value
resourceType stream
resourceType object
resourceType project
resourceType comment

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseComment
400 Bad Request Fail whale. ResponseBase

CommentGet

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/comments/{commentId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/comments/{commentId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/comments/{commentId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/comments/{commentId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/comments/{commentId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/comments/{commentId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/comments/{commentId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /comments/{commentId}

CommentGet

Gets a specific comment.

Parameters

Parameter In Type Required Description
commentId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseComment
400 Bad Request Fail whale. ResponseBase

CommentUpdate

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/comments/{commentId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/comments/{commentId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/comments/{commentId}',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "resource": {},
  "text": "string",
  "assignedTo": [],
  "closed": true,
  "labels": [],
  "view": {},
  "screenshot": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/comments/{commentId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/comments/{commentId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/comments/{commentId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/comments/{commentId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /comments/{commentId}

CommentUpdate

Updates a comment.

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "resource": {},
  "text": "string",
  "assignedTo": [],
  "closed": true,
  "labels": [],
  "view": {},
  "screenshot": "string"
}

Parameters

Parameter In Type Required Description
commentId path string true No description
body body Comment true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

CommentDelete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/api/v1/comments/{commentId} \
  -H 'Accept: application/json'


DELETE http://localhost:3000/api/v1/comments/{commentId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/comments/{commentId}',
  method: 'delete',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/comments/{commentId}',
{
  method: 'DELETE',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.delete 'http://localhost:3000/api/v1/comments/{commentId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.delete('http://localhost:3000/api/v1/comments/{commentId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/comments/{commentId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


DELETE /comments/{commentId}

CommentDelete

Deletes a specific comment.

Parameters

Parameter In Type Required Description
commentId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

Streams

Create, get and update streams.

StreamsGetAll

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/streams \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/streams HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/streams',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/streams', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /streams

StreamsGetAll

Gets a user's streams.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseStream
400 Bad Request Fail whale. ResponseBase

StreamCreate

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/streams \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/streams HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "streamId": "string",
  "name": "string",
  "objects": [],
  "layers": [],
  "baseProperties": {},
  "globalMeasures": {},
  "isComputedResult": false,
  "viewerLayers": [],
  "parent": "string",
  "children": [],
  "ancestors": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/streams',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/streams', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /streams

StreamCreate

Create a stream

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "streamId": "string",
  "name": "string",
  "objects": [],
  "layers": [],
  "baseProperties": {},
  "globalMeasures": {},
  "isComputedResult": false,
  "viewerLayers": [],
  "parent": "string",
  "children": [],
  "ancestors": []
}

Parameters

Parameter In Type Required Description
body body SpeckleStream true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseStream
400 Bad Request Fail whale. ResponseBase

StreamGet

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/streams/{streamId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/streams/{streamId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams/{streamId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams/{streamId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/streams/{streamId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/streams/{streamId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams/{streamId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /streams/{streamId}

StreamGet

Gets a specific stream.

Parameters

Parameter In Type Required Description
streamId path string true No description
query query string false Specifiy which fields to retrieve, ie ?fields=layers,baseProperties.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseStream
400 Bad Request Fail whale. ResponseBase

StreamUpdate

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/streams/{streamId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/streams/{streamId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams/{streamId}',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "streamId": "string",
  "name": "string",
  "objects": [],
  "layers": [],
  "baseProperties": {},
  "globalMeasures": {},
  "isComputedResult": false,
  "viewerLayers": [],
  "parent": "string",
  "children": [],
  "ancestors": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams/{streamId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/streams/{streamId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/streams/{streamId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams/{streamId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /streams/{streamId}

StreamUpdate

Updates a stream.

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "streamId": "string",
  "name": "string",
  "objects": [],
  "layers": [],
  "baseProperties": {},
  "globalMeasures": {},
  "isComputedResult": false,
  "viewerLayers": [],
  "parent": "string",
  "children": [],
  "ancestors": []
}

Parameters

Parameter In Type Required Description
streamId path string true No description
body body SpeckleStream true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

StreamDelete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/api/v1/streams/{streamId} \
  -H 'Accept: application/json'


DELETE http://localhost:3000/api/v1/streams/{streamId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams/{streamId}',
  method: 'delete',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams/{streamId}',
{
  method: 'DELETE',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.delete 'http://localhost:3000/api/v1/streams/{streamId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.delete('http://localhost:3000/api/v1/streams/{streamId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams/{streamId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


DELETE /streams/{streamId}

StreamDelete

Deletes a specific stream.

Parameters

Parameter In Type Required Description
streamId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

StreamGetObjects

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/streams/{streamId}/objects \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/streams/{streamId}/objects HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams/{streamId}/objects',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams/{streamId}/objects',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/streams/{streamId}/objects',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/streams/{streamId}/objects', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams/{streamId}/objects");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /streams/{streamId}/objects

StreamGetObjects

Gets stream objects.

Parameters

Parameter In Type Required Description
streamId path string true No description
query query string false Specifiy which fields to retrieve, filters, limits, etc.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseObject
400 Bad Request Fail whale. ResponseBase

StreamClone

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/streams/{streamId}/clone \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/streams/{streamId}/clone HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams/{streamId}/clone',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams/{streamId}/clone',
{
  method: 'POST',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/streams/{streamId}/clone',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/streams/{streamId}/clone', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams/{streamId}/clone");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /streams/{streamId}/clone

StreamClone

Clones a stream.

Parameters

Parameter In Type Required Description
streamId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": [],
  "clone": {},
  "parent": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseStreamClone
400 Bad Request Fail whale. ResponseBase

StreamDiff

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/streams/{streamId}/diff/{otherStreamId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /streams/{streamId}/diff/{otherStreamId}

StreamDiff

Diffs two streams (objects and layers).

Parameters

Parameter In Type Required Description
streamId path string true No description
otherStreamId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": [],
  "objects": {},
  "layers": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseStreamDiff
400 Bad Request Fail whale. ResponseBase

Objects

Create, get and update objects.

ObjectCreate

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/objects \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/objects HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/objects',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '[
  {}
]';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/objects',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/objects',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/objects', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/objects");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /objects

ObjectCreate

Create one or more objects

Body parameter

[
  {}
]

Parameters

Parameter In Type Required Description
body body array[object] false No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's projects. ResponseObject
400 Bad Request Fail whale. ResponseBase

ObjectUpdate

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/objects/{objectId} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/objects/{objectId} HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/objects/{objectId}',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/objects/{objectId}',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/objects/{objectId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/objects/{objectId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/objects/{objectId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /objects/{objectId}

ObjectUpdate

Update a object

Body parameter

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}

Parameters

Parameter In Type Required Description
objectId path string true No description
body body SpeckleObject true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All the users's projects. ResponseObject
400 Bad Request Fail whale. ResponseBase

ObjectGet

Code samples

# You can also use wget
curl -X GET http://localhost:3000/api/v1/objects/{objectId} \
  -H 'Accept: application/json'


GET http://localhost:3000/api/v1/objects/{objectId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/objects/{objectId}',
  method: 'get',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/objects/{objectId}',
{
  method: 'GET',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.get 'http://localhost:3000/api/v1/objects/{objectId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.get('http://localhost:3000/api/v1/objects/{objectId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/objects/{objectId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


GET /objects/{objectId}

ObjectGet

Get a object

Parameters

Parameter In Type Required Description
objectId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK The client. ResponseObject
400 Bad Request Fail whale. ResponseBase

ObjectDelete

Code samples

# You can also use wget
curl -X DELETE http://localhost:3000/api/v1/objects/{objectId} \
  -H 'Accept: application/json'


DELETE http://localhost:3000/api/v1/objects/{objectId} HTTP/1.1
Host: localhost:3000


Accept: application/json


var headers = {
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/objects/{objectId}',
  method: 'delete',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');


const headers = {
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/objects/{objectId}',
{
  method: 'DELETE',


  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Accept' => 'application/json'
}


result = RestClient.delete 'http://localhost:3000/api/v1/objects/{objectId}',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Accept': 'application/json'
}


r = requests.delete('http://localhost:3000/api/v1/objects/{objectId}', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/objects/{objectId}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("DELETE");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


DELETE /objects/{objectId}

ObjectDelete

Deletes an object

Parameters

Parameter In Type Required Description
objectId path string true No description

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase
400 Bad Request Fail whale. ResponseBase

ObjectUpdateProperties

Code samples

# You can also use wget
curl -X PUT http://localhost:3000/api/v1/objects/{objectId}/properties \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


PUT http://localhost:3000/api/v1/objects/{objectId}/properties HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/objects/{objectId}/properties',
  method: 'put',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '{}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/objects/{objectId}/properties',
{
  method: 'PUT',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.put 'http://localhost:3000/api/v1/objects/{objectId}/properties',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.put('http://localhost:3000/api/v1/objects/{objectId}/properties', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/objects/{objectId}/properties");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("PUT");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


PUT /objects/{objectId}/properties

ObjectUpdateProperties

Does a merge update of the object's properties.

Body parameter

{}

Parameters

Parameter In Type Required Description
objectId path string true No description
body body object true An object that holds the keys you want to modify or add.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseBase

ObjectGetBulk

Code samples

# You can also use wget
curl -X POST http://localhost:3000/api/v1/objects/getbulk \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json'


POST http://localhost:3000/api/v1/objects/getbulk HTTP/1.1
Host: localhost:3000
Content-Type: application/json
Accept: application/json


var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


$.ajax({
  url: 'http://localhost:3000/api/v1/objects/getbulk',
  method: 'post',


  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})


const request = require('node-fetch');
const inputBody = '[
  "string"
]';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json'


};


fetch('http://localhost:3000/api/v1/objects/getbulk',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});


require 'rest-client'
require 'json'


headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json'
}


result = RestClient.post 'http://localhost:3000/api/v1/objects/getbulk',
  params: {
  }, headers: headers


p JSON.parse(result)


import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json'
}


r = requests.post('http://localhost:3000/api/v1/objects/getbulk', params={


}, headers = headers)


print r.json()


URL obj = new URL("http://localhost:3000/api/v1/objects/getbulk");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());


POST /objects/getbulk

ObjectGetBulk

Gets a load of objects

Body parameter

[
  "string"
]

Parameters

Parameter In Type Required Description
query query string false Specifiy which fields to retrieve, filters, limits, etc. For example, ?fields=type,properties,hash&type=Circle
body body array[string] true An object that holds the keys you want to modify or add.

Example responses

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}
{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Responses

Status Meaning Description Schema
200 OK All good! ResponseObject
400 Bad Request Fail whale. ResponseBase

Schemas

ResourceBase

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false
}

Properties

Name Type Required Description
_id string false No description
owner string false No description
private boolean false No description
anonymousComments boolean false No description
canRead [string] false No description
canWrite [string] false No description
comments [string] false An array of comment ids.
deleted boolean false Controls archival status - does not actually delete anything

User

{
  "_id": "string",
  "role": "string",
  "avatar": "string",
  "apitoken": "string",
  "token": "string",
  "email": "string",
  "name": "string",
  "surname": "string",
  "company": "string",
  "logins": []
}

Properties

Name Type Required Description
_id string false Database uuid.
role string false User's role. Defaults to "user".
avatar string false We will need profile pics at one point.
apitoken string false a signed jwt token that expires in 1 year.
token string false a signed jwt token that expires in 1 day.
email string false user's email
name string false User's given name
surname string false User's family name
company string false Users's company
logins [object] false an array storing each time the user logged in.
» date string false No description

AppClient

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "role": "string",
  "documentGuid": "string",
  "documentName": "string",
  "documentType": "string",
  "documentLocation": "string",
  "streamId": "string",
  "online": true
}

Properties

allOf

Name Type Required Description
anonymous ResourceBase false No description

and

Name Type Required Description
anonymous object false No description
» _id string false Database uuid.
» role string false Either Sender, Receiver or anything else you can think of.
» documentGuid string false No description
» documentName string false No description
» documentType string false No description
» documentLocation string false No description
» streamId string false The streamId that this client is attached to.
» online boolean false Is it accessible from the server or not?

Project

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "name": "string",
  "number": "string",
  "users": [],
  "streams": [],
  "subProjects": []
}

Properties

allOf

Name Type Required Description
anonymous ResourceBase false No description

and

Name Type Required Description
anonymous object false No description
» _id string false No description
» name string false No description
» number string false No description
» users [string] false No description
» streams [string] false No description
» subProjects [string] false No description

Comment

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "resource": {},
  "text": "string",
  "assignedTo": [],
  "closed": true,
  "labels": [],
  "view": {},
  "screenshot": "string"
}

Properties

allOf

Name Type Required Description
anonymous ResourceBase false No description

and

Name Type Required Description
anonymous object false No description
» resource object false No description
»» resourceType string false No description
»» resourceId string false No description
» text string false No description
» assignedTo [string] false No description
» closed boolean false No description
» labels [string] false No description
» view object false No description
» screenshot string false No description

SpeckleStream

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "streamId": "string",
  "name": "string",
  "objects": [],
  "layers": [],
  "baseProperties": {},
  "globalMeasures": {},
  "isComputedResult": false,
  "viewerLayers": [],
  "parent": "string",
  "children": [],
  "ancestors": []
}

Properties

allOf

Name Type Required Description
anonymous ResourceBase false No description

and

Name Type Required Description
anonymous object false No description
» streamId string false The stream's short id.
» name string false The data stream's name
» objects [SpeckleObject] false An array of SpeckleObject ids.
» layers [Layer] false An array of speckle layers.
» baseProperties object false Units, tolerances, etc.
» globalMeasures object false Any performance measures can go in here.
» isComputedResult boolean false No description
» viewerLayers [object] false No description
» parent string false If this stream is a child, the parent's streamId.
» children [string] false An array of the streamId of any children of this stream.
» ancestors [string] false If resulting from a merge, the streams that this one was born out of.

Layer

{
  "name": "string",
  "guid": "string",
  "orderIndex": 0,
  "startIndex": 0,
  "objectCount": 0,
  "topology": "string",
  "properties": {}
}

Properties

Name Type Required Description
name string false Layer's name
guid string false Layer's guid (must be unique)
orderIndex integer false Describes this layer's position in the list of layers.
startIndex number false The index of the first object relative to the stream's objects array
objectCount number false How many objects does this layer have.
topology string false String describing the nested tree structure (GH centric).
properties LayerProperties false No description

LayerProperties

{
  "color": {},
  "visible": true,
  "pointsize": 0,
  "linewidth": 0,
  "shininess": 0,
  "smooth": true,
  "showEdges": true,
  "wireframe": true
}

Properties

Name Type Required Description
color object false No description
» a number false alpha value
» hex string false hex color value
visible boolean false toggles layer visibility.
pointsize number false defines point size in threejs
linewidth number false defines line thickness in threejs
shininess number false says it all. speckle is superficial.
smooth boolean false smooth shading toggle
showEdges boolean false display edges or not yo.
wireframe boolean false i'm bored.

ResponseBase

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": []
}

Properties

Name Type Required Description
success boolean false Besides the http status code, this tells you whether the call succeeded or not.
message string false Either an error or a confirmation.
resource object false Returned resource (if querying by id)
resources [object] false Returned resources array (if it's a bulk query)

ResponseUser

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» resource User false No description
» resources [User] false No description

ResponseClient

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» resource AppClient false No description
» resources [AppClient] false No description

ResponseProject

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» resource Project false No description
» resources [Project] false No description

ResponseComment

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» resource Comment false No description
» resources [Comment] false No description

ResponseStream

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» resource SpeckleStream false No description
» resources [SpeckleStream] false No description

ResponseObject

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» resource SpeckleObject false No description
» resources [SpeckleObject] false No description

ResponseStreamClone

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": [],
  "clone": {},
  "parent": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» clone SpeckleStream false No description
» parent SpeckleStream false No description

ResponseStreamDiff

{
  "success": true,
  "message": "string",
  "resource": {},
  "resources": [],
  "objects": {},
  "layers": {}
}

Properties

allOf

Name Type Required Description
anonymous ResponseBase false No description

and

Name Type Required Description
anonymous object false No description
» objects object false No description
»» common [string] false No description
»» inA [string] false No description
»» inB [string] false No description
» layers object false No description
»» common [Layer] false No description
»» inA [Layer] false No description
»» inB [Layer] false No description

SpeckleObject

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}

Properties

allOf

Name Type Required Description
anonymous ResourceBase false No description

and

Name Type Required Description
anonymous object false No description
» type string false Object's subtype
» hash string false Object's unique hash.
» geometryHash string false Object's geometry hash
» applicationId string false The id/guid that the origin application identifies this object by.
» properties object false The extra properties field of a speckle object.
» parent string false If this object is a child, the parent's objectid.
» children [string] false An array of the ids of any children of this object.
» ancestors [string] false If resulting from a merge, the objects that this one was born out of.
» transform [number] false No description

Enumerated Values

Property Value
type Null
type Abstract
type Placeholder
type Boolean
type Number
type String
type Interval
type Interval2d
type Point
type Vector
type Plane
type Line
type Rectangle
type Circle
type Arc
type Ellipse
type Polycurve
type Box
type Polyline
type Curve
type Mesh
type Brep
type Annotation
type Extrusion

SpeckleAbstract

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Abstract",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "_type": "string",
  "assembly": "string"
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» _type string false the original type of the object
» assembly string false the original assembly of this object

SpecklePlaceholder

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Abstract",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description

SpeckleBoolean

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Boolean",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": true
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» value boolean false No description

SpeckleNumber

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Number",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": 0
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» value number false A number. Can be float, double, etc.

SpeckleString

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "String",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": "string"
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» value string false A string.

SpeckleInterval

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Interval",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "start": 0,
  "end": 0
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» start number false No description
» end number false No description

SpeckleInterval2d

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "U": {},
  "V": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» U SpeckleInterval false No description
» V SpeckleInterval false No description

SpecklePoint

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Point",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» value [number] false An array containing the X, Y and Z coords of the point.

SpeckleVector

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Vector",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» value [number] false An array containing the X, Y and Z coords of the vector.

SpecklePlane

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Plane",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "origin": {},
  "normal": {},
  "xdir": {},
  "ydir": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» origin SpecklePoint false No description
» normal SpeckleVector false No description
» xdir SpeckleVector false No description
» ydir SpeckleVector false No description

SpeckleCircle

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Circle",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "radius": 0,
  "center": {},
  "normal": {},
  "domain": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» radius number false No description
» center SpecklePoint false No description
» normal SpeckleVector false No description
» domain SpeckleInterval false No description

SpeckleArc

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Arc",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "radius": 0,
  "startAngle": 0,
  "endAngle": 0,
  "angleRadians": 0,
  "plane": {},
  "domain": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» radius number false No description
» startAngle number false No description
» endAngle number false No description
» angleRadians number false No description
» plane SpecklePlane false No description
» domain SpeckleInterval false No description

SpeckleEllipse

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Ellipse",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "firstRadius": 0,
  "secondRadius": 0,
  "plane": {},
  "domain": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» firstRadius number false No description
» secondRadius number false No description
» plane SpecklePlane false No description
» domain SpeckleInterval false No description

SpecklePolycurve

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Polycurve",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "segments": [],
  "domain": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» segments [SpeckleObject] false No description
» domain SpeckleInterval false No description

SpeckleBox

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Box",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "basePlane": {},
  "xSize": {},
  "ySize": {},
  "zSize": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» basePlane SpecklePlane false No description
» xSize SpeckleInterval false No description
» ySize SpeckleInterval false No description
» zSize SpeckleInterval false No description

SpeckleLine

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Line",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "value": [],
  "domain": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» value [number] false No description
» domain SpeckleInterval false No description

SpecklePolyline

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Polyline",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "closed": true,
  "value": [],
  "domain": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» closed boolean false No description
» value [number] false No description
» domain SpeckleInterval false No description

SpeckleCurve

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Curve",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "degree": 0,
  "periodic": true,
  "rational": true,
  "points": [],
  "weights": [],
  "knots": [],
  "domain": {},
  "displayValue": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» degree number false No description
» periodic boolean false No description
» rational boolean false No description
» points [number] false No description
» weights [number] false No description
» knots [number] false No description
» domain SpeckleInterval false No description
» displayValue SpecklePolyline false No description

SpeckleMesh

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Mesh",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "vertices": [],
  "faces": [],
  "colors": [],
  "textureCoordinates": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» vertices [number] false The mesh's vertices array, in a flat array (ie, x1, y1, z1, x2, y2, ...)
» faces [number] false The faces array.
» colors [number] false If any, the colours per vertex.
» textureCoordinates [number] false The faces array.

SpeckleBrep

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Brep",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "rawData": {},
  "provenance": "string",
  "displayValue": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» type any false No description
» rawData object false The brep's raw (serialisation) data.
» provenance string false A short prefix of where the base64 comes from.
» displayValue SpeckleMesh false No description

SpeckleExtrusion

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "capped": true,
  "profile": {},
  "pathStart": {},
  "pathEnd": {},
  "pathCurve": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» capped boolean false No description
» profile SpeckleObject false No description
» pathStart SpecklePoint false No description
» pathEnd SpecklePoint false No description
» pathCurve SpeckleObject false No description

SpeckleAnnotation

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "text": "string",
  "textHeight": 0,
  "fontName": "string",
  "bold": true,
  "italic": true,
  "location": {},
  "plane": {}
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» text string false No description
» textHeight number false No description
» fontName string false No description
» bold boolean false No description
» italic boolean false No description
» location SpecklePoint false No description
» plane SpecklePlane false No description

SpeckleBlock

{
  "_id": "string",
  "owner": "string",
  "private": true,
  "anonymousComments": true,
  "canRead": [],
  "canWrite": [],
  "comments": [],
  "deleted": false,
  "type": "Null",
  "hash": "hash",
  "geometryHash": "Type.hash",
  "applicationId": "GUID",
  "properties": {},
  "parent": "string",
  "children": [],
  "ancestors": [],
  "transform": [],
  "name": "string",
  "description": "string",
  "objects": []
}

Properties

allOf - discriminator: SpeckleObject.type

Name Type Required Description
anonymous SpeckleObject false No description

and

Name Type Required Description
anonymous object false No description
» name string false No description
» description string false No description
» objects [SpeckleObject] false No description